Merge pull request #3214 from monopole/pin_cmd_config_v0.8.5

Pin to cmd/config/v0.8.5

.dockerignore

@@ -0,0 +1,8 @@
+.github
+docs
+examples
+functions
+hack
+site
+travis
+*.md

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,68 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ""
+labels:
+  - kind/bug
+assignees: ""
+---
+
+<!--
+Please read this page: https://kubernetes-sigs.github.io/kustomize/contributing/bugs/ before
+filing a bug
+-->
+
+<!-- Feel free to skip the sections if they are not applicable. -->
+
+**Describe the bug**
+
+<!-- A clear and concise description of what the bug is. -->
+
+**Files that can reproduce the issue**
+
+<!--
+We cannot figure out or fix the issue if we don't know how to reproduce. Please
+provide a minimum set of files that can reproduce the issue. You can paste the
+file contents here or provide a link to a tarball or git repo.
+
+Example:
+
+kustomization.yaml
+
+```
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+...
+```
+
+resources.yaml
+
+```
+apiVersion: v1
+kind: Deployment
+...
+```
+
+...
+-->
+
+**Expected output**
+
+<!-- What's the expected output? -->
+
+**Actual output**
+
+<!-- What's the actual output? -->
+
+**Kustomize version**
+
+<!-- Please use the latest version when it's possible. -->
+
+**Platform**
+
+<!-- Linux/macOS/Windows? -->
+
+**Additional context**
+
+<!-- Add any other context about the problem here. -->

.github/ISSUE_TEMPLATE/config.yaml

@@ -0,0 +1 @@
+blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,26 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ""
+labels:
+  - kind/feature
+assignees: ""
+---
+
+<!-- Feel free to skip the sections if they are not applicable. -->
+
+**Is your feature request related to a problem? Please describe.**
+
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+**Describe the solution you'd like**
+
+<!-- A clear and concise description of what you want to happen. -->
+
+**Describe alternatives you've considered**
+
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+**Additional context**
+
+<!-- Add any other context or screenshots about the feature request here. -->

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,9 @@
+---
+name: Question
+about: Ask a question about the kustomize
+title: "[Question]"
+labels: ""
+assignees: ""
+---
+
+<!-- Please describe your question here -->

.github/workflows/go.yml

@@ -23,7 +23,7 @@ jobs:
       uses: actions/checkout@v2
 
     - name: Lint
-      run: ./travis/kyaml-pre-commit.sh
+      run: ./scripts/kyaml-pre-commit.sh
       env:
         KUSTOMIZE_DOCKER_E2E: false # don't need to do e2e tests for linting
 

Makefile

@@ -6,6 +6,17 @@
 MYGOBIN := $(shell go env GOPATH)/bin
 SHELL := /bin/bash
 export PATH := $(MYGOBIN):$(PATH)
+MODULES := '"cmd/config" "api/" "kustomize/" "kyaml/"'
+
+# Provide defaults for REPO_OWNER and REPO_NAME if not present.
+# Typically these values would be provided by Prow.
+ifndef REPO_OWNER
+REPO_OWNER := "kubernetes-sigs"
+endif
+
+ifndef REPO_NAME
+REPO_NAME := "kustomize"
+endif
 
 .PHONY: all
 all: verify-kustomize
@@ -15,7 +26,7 @@ verify-kustomize: \
 	lint-kustomize \
 	test-unit-kustomize-all \
 	test-examples-kustomize-against-HEAD \
-	test-examples-kustomize-against-3.8.0
+	test-examples-kustomize-against-3.8.6
 
 # The following target referenced by a file in
 # https://github.com/kubernetes/test-infra/tree/master/config/jobs/kubernetes-sigs/kustomize
@@ -26,7 +37,11 @@ prow-presubmit-check: \
 	test-unit-cmd-all \
 	test-go-mod \
 	test-examples-kustomize-against-HEAD \
-	test-examples-kustomize-against-3.8.0
+	test-examples-kustomize-against-3.8.6
+
+# test-multi-module \
+# Temporarily removed from prow-presubmit-check
+# See https://github.com/kubernetes-sigs/kustomize/issues/3191
 
 .PHONY: verify-kustomize-e2e
 verify-kustomize-e2e: test-examples-e2e-kustomize
@@ -45,34 +60,37 @@ $(MYGOBIN)/golangci-lint-kustomize:
 		GO111MODULE=on go build -tags=tools -o $(MYGOBIN)/golangci-lint-kustomize github.com/golangci/golangci-lint/cmd/golangci-lint; \
 	)
 
-# Version pinned by api/go.mod
+# Install from version specified in api/go.mod.
 $(MYGOBIN)/mdrip:
 	cd api; \
 	go install github.com/monopole/mdrip
 
-# Version pinned by api/go.mod
+# Install from version specified in api/go.mod.
 $(MYGOBIN)/stringer:
 	cd api; \
 	go install golang.org/x/tools/cmd/stringer
 
-# Version pinned by api/go.mod
+# Install from version specified in api/go.mod.
 $(MYGOBIN)/goimports:
 	cd api; \
 	go install golang.org/x/tools/cmd/goimports
 
-# Install resource from whatever is checked out.
-$(MYGOBIN)/resource:
-	cd cmd/resource; \
+# Build from local source.
+$(MYGOBIN)/gorepomod:
+	cd cmd/gorepomod; \
 	go install .
 
-# To pin pluginator, use this recipe instead:
-#   cd api;
-#   go install sigs.k8s.io/kustomize/pluginator/v2
+# Build from local source.
 $(MYGOBIN)/pluginator:
-	cd pluginator; \
+	cd cmd/pluginator; \
 	go install .
 
-# Install kustomize from whatever is checked out.
+# Build from local source.
+$(MYGOBIN)/prchecker:
+	cd cmd/prchecker; \
+	go install .
+
+# Build from local source.
 $(MYGOBIN)/kustomize:
 	cd kustomize; \
 	go install .
@@ -81,9 +99,13 @@ $(MYGOBIN)/kustomize:
 install-tools: \
 	$(MYGOBIN)/goimports \
 	$(MYGOBIN)/golangci-lint-kustomize \
+	$(MYGOBIN)/gh \
+	$(MYGOBIN)/gorepomod \
 	$(MYGOBIN)/mdrip \
 	$(MYGOBIN)/pluginator \
-	$(MYGOBIN)/stringer
+	$(MYGOBIN)/prchecker \
+	$(MYGOBIN)/stringer \
+	$(MYGOBIN)/helm
 
 ### Begin kustomize plugin rules.
 #
@@ -125,7 +147,8 @@ _builtinplugins = \
 	PrefixSuffixTransformer.go \
 	ReplicaCountTransformer.go \
 	SecretGenerator.go \
-	ValueAddTransformer.go
+	ValueAddTransformer.go \
+	HelmChartInflationGenerator.go
 
 # Maintaining this explicit list of generated files, and
 # adding it as a dependency to a few targets, to assure
@@ -151,6 +174,7 @@ $(pGen)/PrefixSuffixTransformer.go: $(pSrc)/prefixsuffixtransformer/PrefixSuffix
 $(pGen)/ReplicaCountTransformer.go: $(pSrc)/replicacounttransformer/ReplicaCountTransformer.go
 $(pGen)/SecretGenerator.go: $(pSrc)/secretgenerator/SecretGenerator.go
 $(pGen)/ValueAddTransformer.go: $(pSrc)/valueaddtransformer/ValueAddTransformer.go
+$(pGen)/HelmChartInflationGenerator.go: $(pSrc)/helmchartinflationgenerator/HelmChartInflationGenerator.go
 
 # The (verbose but portable) Makefile way to convert to lowercase.
 toLowerCase = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))
@@ -185,8 +209,8 @@ lint-kustomize: install-tools $(builtinplugins)
 	$(MYGOBIN)/golangci-lint-kustomize -c ../.golangci-kustomize.yml run ./...
 	cd kustomize; \
 	$(MYGOBIN)/golangci-lint-kustomize -c ../.golangci-kustomize.yml run ./...
-	cd pluginator; \
-	$(MYGOBIN)/golangci-lint-kustomize -c ../.golangci-kustomize.yml run ./...
+	cd cmd/pluginator; \
+	$(MYGOBIN)/golangci-lint-kustomize -c ../../.golangci-kustomize.yml run ./...
 
 # Used to add non-default compilation flags when experimenting with
 # plugin-to-api compatibility checks.
@@ -213,10 +237,23 @@ test-unit-kustomize-all: \
 	test-unit-kustomize-plugins
 
 test-unit-cmd-all:
-	./travis/kyaml-pre-commit.sh
+	./scripts/kyaml-pre-commit.sh
 
 test-go-mod:
-	./travis/check-go-mod.sh
+	./scripts/check-go-mod.sh
+
+# Environment variables are defined at
+# https://github.com/kubernetes/test-infra/blob/master/prow/jobs.md#job-environment-variables
+.PHONY: test-multi-module
+test-multi-module: $(MYGOBIN)/prchecker
+	( \
+		export MYGOBIN=$(MYGOBIN); \
+		export REPO_OWNER=$(REPO_OWNER); \
+		export REPO_NAME=$(REPO_NAME); \
+		export PULL_NUMBER=$(PULL_NUMBER); \
+		export MODULES=$(MODULES); \
+		./scripts/check-multi-module.sh; \
+	)
 
 .PHONY:
 test-examples-e2e-kustomize: $(MYGOBIN)/mdrip $(MYGOBIN)/kind
@@ -233,10 +270,10 @@ test-examples-kustomize-against-HEAD: $(MYGOBIN)/kustomize $(MYGOBIN)/mdrip
 	./hack/testExamplesAgainstKustomize.sh HEAD
 
 .PHONY:
-test-examples-kustomize-against-3.8.0: $(MYGOBIN)/mdrip
+test-examples-kustomize-against-3.8.6: $(MYGOBIN)/mdrip
 	( \
 		set -e; \
-		tag=v3.8.0; \
+		tag=v3.8.6; \
 		/bin/rm -f $(MYGOBIN)/kustomize; \
 		echo "Installing kustomize $$tag."; \
 		GO111MODULE=on go get sigs.k8s.io/kustomize/kustomize/v3@$${tag}; \
@@ -283,16 +320,16 @@ $(MYGOBIN)/helmV3:
 	( \
 		set -e; \
 		d=$(shell mktemp -d); cd $$d; \
-		tgzFile=helm-v3.2.0-rc.1-linux-amd64.tar.gz; \
+		tgzFile=helm-v3.4.0-linux-amd64.tar.gz; \
 		wget https://get.helm.sh/$$tgzFile; \
 		tar -xvzf $$tgzFile; \
 		mv linux-amd64/helm $(MYGOBIN)/helmV3; \
 		rm -rf $$d \
 	)
 
-# Default version of helm is v2 for the time being.
-$(MYGOBIN)/helm: $(MYGOBIN)/helmV2
-	ln -s $(MYGOBIN)/helmV2 $(MYGOBIN)/helm
+# Default version of helm is v3.
+$(MYGOBIN)/helm: $(MYGOBIN)/helmV3
+	ln -s $(MYGOBIN)/helmV3 $(MYGOBIN)/helm
 
 $(MYGOBIN)/kind:
 	( \
@@ -304,6 +341,18 @@ $(MYGOBIN)/kind:
         rm -rf $$d; \
 	)
 
+# linux only.
+$(MYGOBIN)/gh:
+	( \
+		set -e; \
+		d=$(shell mktemp -d); cd $$d; \
+		tgzFile=gh_1.0.0_linux_amd64.tar.gz; \
+		wget https://github.com/cli/cli/releases/download/v1.0.0/$$tgzFile; \
+		tar -xvzf $$tgzFile; \
+		mv gh_1.0.0_linux_amd64/bin/gh  $(MYGOBIN)/gh; \
+		rm -rf $$d \
+	)
+
 .PHONY: clean
 clean: kustomize-external-go-plugin-clean
 	go clean --cache

OWNERS_ALIASES

@@ -11,3 +11,4 @@ aliases:
     - pwittrock
     - mortent
     - phanimarupaka
+    - Shell32-Natsu

api/builtins/HelmChartInflationGenerator.go

@@ -0,0 +1,178 @@
+// Code generated by pluginator on HelmChartInflationGenerator; DO NOT EDIT.
+// pluginator {unknown  1970-01-01T00:00:00Z  }
+
+package builtins
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"regexp"
+	"strings"
+
+	"github.com/pkg/errors"
+	"sigs.k8s.io/kustomize/api/filesys"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/yaml"
+)
+
+// HelmChartInflationGeneratorPlugin is a plugin to generate resources
+// from a remote or local helm chart.
+type HelmChartInflationGeneratorPlugin struct {
+	h                *resmap.PluginHelpers
+	types.ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+	runHelmCommand   func([]string) ([]byte, error)
+	types.HelmChartArgs
+	tmpDir string
+}
+
+var KustomizePlugin HelmChartInflationGeneratorPlugin
+
+// Config uses the input plugin configurations `config` to setup the generator
+// options
+func (p *HelmChartInflationGeneratorPlugin) Config(h *resmap.PluginHelpers, config []byte) error {
+	p.h = h
+	err := yaml.Unmarshal(config, p)
+	if err != nil {
+		return err
+	}
+	tmpDir, err := filesys.NewTmpConfirmedDir()
+	if err != nil {
+		return err
+	}
+	p.tmpDir = string(tmpDir)
+	if p.ChartName == "" {
+		return fmt.Errorf("chartName cannot be empty")
+	}
+	if p.ChartHome == "" {
+		p.ChartHome = path.Join(p.tmpDir, "chart")
+	}
+	if p.ChartRepoName == "" {
+		p.ChartRepoName = "stable"
+	}
+	if p.HelmBin == "" {
+		p.HelmBin = "helm"
+	}
+	if p.HelmHome == "" {
+		p.HelmHome = path.Join(p.tmpDir, ".helm")
+	}
+	if p.Values == "" {
+		p.Values = path.Join(p.ChartHome, p.ChartName, "values.yaml")
+	}
+	// runHelmCommand will run `helm` command with args provided. Return stdout
+	// and error if there is any.
+	p.runHelmCommand = func(args []string) ([]byte, error) {
+		stdout := new(bytes.Buffer)
+		stderr := new(bytes.Buffer)
+		cmd := exec.Command(p.HelmBin, args...)
+		cmd.Stdout = stdout
+		cmd.Stderr = stderr
+		cmd.Env = append(cmd.Env,
+			fmt.Sprintf("HELM_CONFIG_HOME=%s", p.HelmHome),
+			fmt.Sprintf("HELM_CACHE_HOME=%s/.cache", p.HelmHome),
+			fmt.Sprintf("HELM_DATA_HOME=%s/.data", p.HelmHome),
+		)
+		err := cmd.Run()
+		if err != nil {
+			return stdout.Bytes(),
+				errors.Wrap(
+					fmt.Errorf("failed to run command %s %s", p.HelmBin, strings.Join(args, " ")),
+					stderr.String(),
+				)
+		}
+		return stdout.Bytes(), nil
+	}
+	return nil
+}
+
+// Generate implements generator
+func (p *HelmChartInflationGeneratorPlugin) Generate() (resmap.ResMap, error) {
+	// cleanup
+	defer os.RemoveAll(p.tmpDir)
+	// check helm version. we only support V3
+	err := p.checkHelmVersion()
+	if err != nil {
+		return nil, err
+	}
+	// pull the chart
+	if !p.checkLocalChart() {
+		_, err := p.runHelmCommand(p.getPullCommandArgs())
+		if err != nil {
+			return nil, err
+		}
+	}
+	// render the charts
+	stdout, err := p.runHelmCommand(p.getTemplateCommandArgs())
+	if err != nil {
+		return nil, err
+	}
+
+	return p.h.ResmapFactory().NewResMapFromBytes(stdout)
+}
+
+func (p *HelmChartInflationGeneratorPlugin) getTemplateCommandArgs() []string {
+	args := []string{"template"}
+	if p.ReleaseName != "" {
+		args = append(args, p.ReleaseName)
+	}
+	args = append(args, path.Join(p.ChartHome, p.ChartName))
+	if p.ReleaseNamespace != "" {
+		args = append(args, "--namespace", p.ReleaseNamespace)
+	}
+	if p.Values != "" {
+		args = append(args, "--values", p.Values)
+	}
+	return args
+}
+
+func (p *HelmChartInflationGeneratorPlugin) getPullCommandArgs() []string {
+	args := []string{"pull", "--untar", "--untardir", p.ChartHome}
+	chartName := fmt.Sprintf("%s/%s", p.ChartRepoName, p.ChartName)
+	if p.ChartVersion != "" {
+		args = append(args, "--version", p.ChartVersion)
+	}
+	if p.ChartRepoURL != "" {
+		args = append(args, "--repo", p.ChartRepoURL)
+		chartName = p.ChartName
+	}
+
+	args = append(args, chartName)
+
+	return args
+}
+
+// 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)
+	s, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+	return s.IsDir()
+}
+
+// checkHelmVersion will return an error if the helm version is not V3
+func (p *HelmChartInflationGeneratorPlugin) checkHelmVersion() error {
+	stdout, err := p.runHelmCommand([]string{"version", "-c", "--short"})
+	if err != nil {
+		return err
+	}
+	r, err := regexp.Compile(`v\d+(\.\d+)+`)
+	if err != nil {
+		return err
+	}
+	v := string(r.Find(stdout))[1:]
+	majorVersion := strings.Split(v, ".")[0]
+	if majorVersion != "3" {
+		return fmt.Errorf("this plugin requires helm V3 but got v%s", v)
+	}
+	return nil
+}
+
+func NewHelmChartInflationGeneratorPlugin() resmap.GeneratorPlugin {
+	return &HelmChartInflationGeneratorPlugin{}
+}

api/builtins/ImageTagTransformer.go

@@ -31,14 +31,15 @@ func (p *ImageTagTransformerPlugin) Config(
 
 func (p *ImageTagTransformerPlugin) Transform(m resmap.ResMap) error {
 	for _, r := range m.Resources() {
-		// If you're here because someone expected any field containing
-		// the string "containers" or "initContainers" to get an image
-		// update (not just spec/template/spec/containers[], etc.) then
-		// a code change is needed.  See api/filters/imagetag/legacy
-		// for the start of an implementation that won't use an
-		// allowlist like FsSlice, and instead walks the object looking
-		// for fields named containers or initContainers.
-		err := filtersutil.ApplyToJSON(imagetag.Filter{
+		// traverse all fields at first
+		err := filtersutil.ApplyToJSON(imagetag.LegacyFilter{
+			ImageTag: p.ImageTag,
+		}, r)
+		if err != nil {
+			return err
+		}
+		// then use user specified field specs
+		err = filtersutil.ApplyToJSON(imagetag.Filter{
 			ImageTag: p.ImageTag,
 			FsSlice:  p.FieldSpecs,
 		}, r)

api/builtins/NamespaceTransformer.go

@@ -7,9 +7,7 @@ import (
 	"fmt"
 
 	"sigs.k8s.io/kustomize/api/filters/namespace"
-	"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/kustomize/kyaml/filtersutil"
 	"sigs.k8s.io/yaml"
@@ -33,7 +31,7 @@ func (p *NamespaceTransformerPlugin) Transform(m resmap.ResMap) error {
 		return nil
 	}
 	for _, r := range m.Resources() {
-		if len(r.Map()) == 0 {
+		if r.IsEmpty() {
 			// Don't mutate empty objects?
 			continue
 		}
@@ -53,74 +51,6 @@ func (p *NamespaceTransformerPlugin) Transform(m resmap.ResMap) error {
 	return nil
 }
 
-// Special casing metadata.namespace since
-// all objects have it, even "ClusterKind" objects
-// that don't exist in a namespace (the Namespace
-// object itself doesn't live in a namespace).
-func (p *NamespaceTransformerPlugin) applicableFieldSpecs(id resid.ResId) []types.FieldSpec {
-	var res []types.FieldSpec
-	for _, fs := range p.FieldSpecs {
-		if id.IsSelected(&fs.Gvk) &&
-			(fs.Path != types.MetadataNamespacePath ||
-				(fs.Path == types.MetadataNamespacePath && id.IsNamespaceableKind())) {
-			res = append(res, fs)
-		}
-	}
-	return res
-}
-
-func (p *NamespaceTransformerPlugin) changeNamespace(
-	_ *resource.Resource) func(in interface{}) (interface{}, error) {
-	return func(in interface{}) (interface{}, error) {
-		switch in.(type) {
-		case string:
-			// will happen when the metadata/namespace
-			// value is replaced
-			return p.Namespace, nil
-		case []interface{}:
-			l, _ := in.([]interface{})
-			for idx, item := range l {
-				switch item.(type) {
-				case map[string]interface{}:
-					// Will happen when mutating the subjects
-					// field of ClusterRoleBinding and RoleBinding
-					inMap, _ := item.(map[string]interface{})
-					if _, ok := inMap["name"]; !ok {
-						continue
-					}
-					name, ok := inMap["name"].(string)
-					if !ok {
-						continue
-					}
-					// The only case we need to force the namespace
-					// if for the "service account". "default" is
-					// kind of hardcoded here for right now.
-					if name != "default" {
-						continue
-					}
-					inMap["namespace"] = p.Namespace
-					l[idx] = inMap
-				default:
-					// nothing to do for right now
-				}
-			}
-			return in, nil
-		case map[string]interface{}:
-			// Will happen if the createField=true
-			// when the namespace is added to the
-			// object
-			inMap := in.(map[string]interface{})
-			if len(inMap) == 0 {
-				return p.Namespace, nil
-			} else {
-				return in, nil
-			}
-		default:
-			return in, nil
-		}
-	}
-}
-
 func NewNamespaceTransformerPlugin() resmap.TransformerPlugin {
 	return &NamespaceTransformerPlugin{}
 }

api/builtins/PatchJson6902Transformer.go

@@ -10,7 +10,6 @@ import (
 	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/filters/patchjson6902"
 	"sigs.k8s.io/kustomize/api/ifc"
-	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/filtersutil"
@@ -20,9 +19,9 @@ import (
 type PatchJson6902TransformerPlugin struct {
 	ldr          ifc.Loader
 	decodedPatch jsonpatch.Patch
-	Target       types.PatchTarget `json:"target,omitempty" yaml:"target,omitempty"`
-	Path         string            `json:"path,omitempty" yaml:"path,omitempty"`
-	JsonOp       string            `json:"jsonOp,omitempty" yaml:"jsonOp,omitempty"`
+	Target       *types.Selector `json:"target,omitempty" yaml:"target,omitempty"`
+	Path         string          `json:"path,omitempty" yaml:"path,omitempty"`
+	JsonOp       string          `json:"jsonOp,omitempty" yaml:"jsonOp,omitempty"`
 }
 
 func (p *PatchJson6902TransformerPlugin) Config(
@@ -72,22 +71,22 @@ func (p *PatchJson6902TransformerPlugin) Config(
 }
 
 func (p *PatchJson6902TransformerPlugin) Transform(m resmap.ResMap) error {
-	id := resid.NewResIdWithNamespace(
-		resid.Gvk{
-			Group:   p.Target.Group,
-			Version: p.Target.Version,
-			Kind:    p.Target.Kind,
-		},
-		p.Target.Name,
-		p.Target.Namespace,
-	)
-	obj, err := m.GetById(id)
+	if p.Target == nil {
+		return fmt.Errorf("must specify a target for patch %s", p.JsonOp)
+	}
+	resources, err := m.Select(*p.Target)
 	if err != nil {
 		return err
 	}
-	return filtersutil.ApplyToJSON(patchjson6902.Filter{
-		Patch: p.JsonOp,
-	}, obj)
+	for _, res := range resources {
+		err = filtersutil.ApplyToJSON(patchjson6902.Filter{
+			Patch: p.JsonOp,
+		}, res)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func NewPatchJson6902TransformerPlugin() resmap.TransformerPlugin {

api/builtins/PatchStrategicMergeTransformer.go

@@ -94,14 +94,14 @@ func (p *PatchStrategicMergeTransformerPlugin) Transform(m resmap.ResMap) error
 				// Some unknown error, let it through.
 				return err
 			}
-			if len(target.Map()) != 0 {
+			if !target.IsEmpty() {
 				return errors.Wrapf(
 					err, "with unexpectedly non-empty object map of size %d",
 					len(target.Map()))
 			}
 			// Fall through to handle deleted object.
 		}
-		if len(target.Map()) == 0 {
+		if target.IsEmpty() {
 			// This means all fields have been removed from the object.
 			// This can happen if a patch required deletion of the
 			// entire resource (not just a part of it).  This means

api/builtins/PatchTransformer.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	jsonpatch "github.com/evanphx/json-patch"
+	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/filters/patchjson6902"
 	"sigs.k8s.io/kustomize/api/filters/patchstrategicmerge"
 	"sigs.k8s.io/kustomize/api/resmap"
@@ -101,7 +102,31 @@ func (p *PatchTransformerPlugin) transformStrategicMerge(m resmap.ResMap, patch
 		patchCopy.SetGvk(res.GetGvk())
 		err := p.applySMPatch(res, patchCopy)
 		if err != nil {
-			return err
+			// Check for an error string from UnmarshalJSON that's indicative
+			// of an object that's missing basic KRM fields, and thus may have been
+			// entirely deleted (an acceptable outcome).  This error handling should
+			// be deleted along with use of ResMap and apimachinery functions like
+			// UnmarshalJSON.
+			if !strings.Contains(err.Error(), "Object 'Kind' is missing") {
+				// Some unknown error, let it through.
+				return err
+			}
+			if !res.IsEmpty() {
+				return errors.Wrapf(
+					err, "with unexpectedly non-empty object map of size %d",
+					len(res.Map()))
+			}
+			// Fall through to handle deleted object.
+		}
+		if res.IsEmpty() {
+			// This means all fields have been removed from the object.
+			// This can happen if a patch required deletion of the
+			// entire resource (not just a part of it).  This means
+			// the overall resmap must shrink by one.
+			err = m.Remove(res.CurId())
+			if err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -114,9 +139,15 @@ func (p *PatchTransformerPlugin) applySMPatch(resource, patch *resource.Resource
 	if err != nil {
 		return err
 	}
-	return filtersutil.ApplyToJSON(patchstrategicmerge.Filter{
+	n, ns := resource.GetName(), resource.GetNamespace()
+	err = filtersutil.ApplyToJSON(patchstrategicmerge.Filter{
 		Patch: node,
 	}, resource)
+	if !resource.IsEmpty() {
+		resource.SetName(n)
+		resource.SetNamespace(ns)
+	}
+	return err
 }
 
 // transformJson6902 applies the provided json6902 patch

api/filters/fieldspec/fieldspec.go

@@ -51,6 +51,9 @@ func (fltr Filter) filter(obj *yaml.RNode) error {
 		// found the field -- set its value
 		return fltr.SetValue(obj)
 	}
+	if obj.IsTaggedNull() {
+		return nil
+	}
 	switch obj.YNode().Kind {
 	case yaml.SequenceNode:
 		return fltr.seq(obj)
@@ -67,7 +70,7 @@ func (fltr Filter) field(obj *yaml.RNode) error {
 	// lookup the field matching the next path element
 	var lookupField yaml.Filter
 	var kind yaml.Kind
-	tag := "" // TODO: change to yaml.NodeTagEmpty
+	tag := yaml.NodeTagEmpty
 	switch {
 	case !fltr.FieldSpec.CreateIfNotPresent || fltr.CreateKind == 0 || isSeq:
 		// dont' create the field if we don't find it
@@ -95,9 +98,10 @@ func (fltr Filter) field(obj *yaml.RNode) error {
 		return errors.WrapPrefixf(err, "fieldName: %s", fieldName)
 	}
 
-	// if the value exists, but is null, then change it to the creation type
+	// if the value exists, but is null and kind is set,
+	// then change it to the creation type
 	// TODO: update yaml.LookupCreate to support this
-	if field.YNode().Tag == yaml.NodeTagNull {
+	if field.YNode().Tag == yaml.NodeTagNull && yaml.IsCreate(kind) {
 		field.YNode().Kind = kind
 		field.YNode().Tag = tag
 	}

api/filters/fieldspec/fieldspec_test.go

@@ -433,7 +433,6 @@ spec:
 			SetValue:   filtersutil.SetScalar("bar"),
 			CreateKind: yaml.ScalarNode,
 		},
-		error: "obj '' at path 'spec/containers/image': expected sequence or mapping node",
 	},
 	{
 		name: "filedname with slash '/'",

api/filters/nameref/nameref.go

@@ -1,7 +1,9 @@
 package nameref
 
 import (
+	"encoding/json"
 	"fmt"
+	"strings"
 
 	"sigs.k8s.io/kustomize/api/filters/fieldspec"
 	"sigs.k8s.io/kustomize/api/filters/filtersutil"
@@ -9,6 +11,7 @@ import (
 	"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/kio"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
@@ -19,6 +22,7 @@ type Filter struct {
 	Referrer           *resource.Resource
 	Target             resid.Gvk
 	ReferralCandidates resmap.ResMap
+	isRoleRef          bool
 }
 
 func (f Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
@@ -37,6 +41,9 @@ 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)
@@ -65,6 +72,7 @@ func (f Filter) setMapping(node *yaml.RNode) error {
 		f.Referrer,
 		f.Target,
 		f.ReferralCandidates,
+		f.isRoleRef,
 	)
 }
 
@@ -75,6 +83,7 @@ func (f Filter) setScalar(node *yaml.RNode) error {
 		f.Target,
 		f.ReferralCandidates,
 		f.ReferralCandidates.Resources(),
+		f.isRoleRef,
 	)
 	if err != nil {
 		return err
@@ -86,6 +95,60 @@ func (f Filter) setScalar(node *yaml.RNode) error {
 	return nil
 }
 
+// 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)
+	if err != nil {
+		return nil, err
+	}
+	roleRef, err := n.Pipe(yaml.Lookup("roleRef"))
+	if err != nil {
+		return nil, err
+	}
+	if roleRef.IsNil() {
+		return nil, fmt.Errorf("roleRef cannot be found in %s", n.MustString())
+	}
+	apiGroup, err := roleRef.Pipe(yaml.Lookup("apiGroup"))
+	if err != nil {
+		return nil, err
+	}
+	if apiGroup.IsNil() {
+		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 &resid.Gvk{
+		Group: apiGroup.YNode().Value,
+		Kind:  kind.YNode().Value,
+	}, 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
+		}
+		if !referrer.PrefixesSuffixesEquals(m) {
+			continue
+		}
+		ret = append(ret, m)
+	}
+	return ret
+}
+
 // 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
@@ -97,18 +160,36 @@ func selectReferral(
 	referrer *resource.Resource,
 	target resid.Gvk,
 	referralCandidates resmap.ResMap,
-	referralCandidateSubset []*resource.Resource) (string, string, error) {
-
+	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 id.IsSelected(&target) && res.GetOriginalName() == oldName {
+		// 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, there's no way
-			// to know which one to pick, so emit error.
+			// If there's more than one match,
+			// filter the matches by prefix and suffix
 			if len(matches) > 1 {
-				return "", "", fmt.Errorf(
-					"multiple matches for %s:\n  %v",
-					id, getIds(matches))
+				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
+				}
 			}
 			// In the resource, note that it is referenced
 			// by the referrer.
@@ -128,10 +209,11 @@ func getSimpleNameField(
 	referrer *resource.Resource,
 	target resid.Gvk,
 	referralCandidates resmap.ResMap,
-	referralCandidateSubset []*resource.Resource) (string, error) {
+	referralCandidateSubset []*resource.Resource,
+	isRoleRef bool) (string, error) {
 
 	newName, _, err := selectReferral(oldName, referrer, target,
-		referralCandidates, referralCandidateSubset)
+		referralCandidates, referralCandidateSubset, isRoleRef)
 
 	return newName, err
 }
@@ -150,7 +232,8 @@ func setNameAndNs(
 	in *yaml.RNode,
 	referrer *resource.Resource,
 	target resid.Gvk,
-	referralCandidates resmap.ResMap) error {
+	referralCandidates resmap.ResMap,
+	isRoleRef bool) error {
 
 	if in.YNode().Kind != yaml.MappingNode {
 		return fmt.Errorf("expect a mapping node")
@@ -186,7 +269,7 @@ func setNameAndNs(
 
 	oldName := nameNode.YNode().Value
 	newname, newnamespace, err := selectReferral(oldName, referrer, target,
-		referralCandidates, subset)
+		referralCandidates, subset, isRoleRef)
 	if err != nil {
 		return err
 	}

api/filters/nameref/nameref_test.go

@@ -168,6 +168,44 @@ metadata:
 map:
   name: newName
   namespace: oldNs
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "map"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+		},
+		"null value": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+map:
+  name: null
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: NotSecret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", ""},
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+map:
+  name: null
 `,
 			filter: Filter{
 				FieldSpec: types.FieldSpec{Path: "map"},
@@ -217,27 +255,6 @@ func TestNamerefFilterUnhappy(t *testing.T) {
 		filter        Filter
 		originalNames []string
 	}{
-		"invalid node type": {
-			input: `
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: dep
-ref:
-  name: null
-`,
-			candidates:    "",
-			originalNames: []string{},
-			expected:      "obj '' at path 'ref/name': node is expected to be either a string or a slice of string or a map of string",
-			filter: Filter{
-				FieldSpec: types.FieldSpec{Path: "ref/name"},
-				Target: resid.Gvk{
-					Group:   "apps",
-					Version: "v1",
-					Kind:    "Secret",
-				},
-			},
-		},
 		"multiple match": {
 			input: `
 apiVersion: apps/v1
@@ -331,3 +348,434 @@ 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
+	}{
+		"prefix match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix1", "prefix2"},
+			suffix:        []string{"", "suffix2"},
+			inputPrefix:   "prefix1",
+			inputSuffix:   "",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: newName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+		"suffix match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"", "prefix2"},
+			suffix:        []string{"suffix1", "suffix2"},
+			inputPrefix:   "",
+			inputSuffix:   "suffix1",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: newName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+		"prefix suffix both match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix1", "prefix2"},
+			suffix:        []string{"suffix1", "suffix2"},
+			inputPrefix:   "prefix1",
+			inputSuffix:   "suffix1",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: newName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+		"multiple match: both": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix", "prefix"},
+			suffix:        []string{"suffix", "suffix"},
+			inputPrefix:   "prefix",
+			inputSuffix:   "suffix",
+			expected:      "",
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: true,
+		},
+		"multiple match: only prefix": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix", "prefix"},
+			suffix:        []string{"", ""},
+			inputPrefix:   "prefix",
+			inputSuffix:   "",
+			expected:      "",
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: true,
+		},
+		"multiple match: only suffix": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"", ""},
+			suffix:        []string{"suffix", "suffix"},
+			inputPrefix:   "",
+			inputSuffix:   "suffix",
+			expected:      "",
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: true,
+		},
+		"no match: neither match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix1", "prefix2"},
+			suffix:        []string{"suffix1", "suffix2"},
+			inputPrefix:   "prefix",
+			inputSuffix:   "suffix",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+		"no match: prefix doesn't match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix1", "prefix2"},
+			suffix:        []string{"suffix", "suffix"},
+			inputPrefix:   "prefix",
+			inputSuffix:   "suffix",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+		"no match: suffix doesn't match": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			candidates: `
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName
+---
+apiVersion: apps/v1
+kind: Secret
+metadata:
+  name: newName2
+`,
+			originalNames: []string{"oldName", "oldName"},
+			prefix:        []string{"prefix", "prefix"},
+			suffix:        []string{"suffix1", "suffix2"},
+			inputPrefix:   "prefix",
+			inputSuffix:   "suffix",
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+ref:
+  name: oldName
+`,
+			filter: Filter{
+				FieldSpec: types.FieldSpec{Path: "ref/name"},
+				Target: resid.Gvk{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "Secret",
+				},
+			},
+			err: false,
+		},
+	}
+
+	for tn, tc := range testCases {
+		t.Run(tn, func(t *testing.T) {
+			factory := resource.NewFactory(kunstruct.NewKunstructuredFactoryImpl())
+			referrer, err := factory.FromBytes([]byte(tc.input))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if tc.inputPrefix != "" {
+				referrer.AddNamePrefix(tc.inputPrefix)
+			}
+			if tc.inputSuffix != "" {
+				referrer.AddNameSuffix(tc.inputSuffix)
+			}
+			tc.filter.Referrer = referrer
+
+			resMapFactory := resmap.NewFactory(factory, nil)
+			candidatesRes, err := factory.SliceFromBytesWithNames(
+				tc.originalNames, []byte(tc.candidates))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for i := range candidatesRes {
+				if tc.prefix[i] != "" {
+					candidatesRes[i].AddNamePrefix(tc.prefix[i])
+				}
+				if tc.suffix[i] != "" {
+					candidatesRes[i].AddNameSuffix(tc.suffix[i])
+				}
+			}
+
+			candidates := resMapFactory.FromResourceSlice(candidatesRes)
+			tc.filter.ReferralCandidates = candidates
+
+			if !tc.err {
+				if !assert.Equal(t,
+					strings.TrimSpace(tc.expected),
+					strings.TrimSpace(
+						filtertest_test.RunFilter(t, tc.input, tc.filter))) {
+					t.FailNow()
+				}
+			} else {
+				_, err := filtertest_test.RunFilterE(t, tc.input, tc.filter)
+				if err == nil {
+					t.Fatalf("an error is expected")
+				}
+			}
+		})
+	}
+}

api/filters/namespace/namespace.go

@@ -69,7 +69,7 @@ func (ns Filter) hacks(obj *yaml.RNode) error {
 // metaNamespaceHack is a hack for implementing the namespace transform
 // for the metadata.namespace field on namespace scoped resources.
 // namespace scoped resources are determined by NOT being present
-// in a blacklist of cluster-scoped resource types (by apiVersion and kind).
+// in a hard-coded list of cluster-scoped resource types (by apiVersion and kind).
 //
 // This hack should be updated to allow individual resources to specify
 // if they are cluster scoped through either an annotation on the resources,

api/filters/namespace/namespace_test.go

@@ -194,47 +194,47 @@ metadata:
 	{
 		name: "update-clusterrolebinding",
 		input: `
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: default
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: default
   namespace: foo
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: something
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: something
   namespace: foo
 `,
 		expected: `
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: default
   namespace: bar
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: default
   namespace: bar
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: something
 ---
-apiVersion: example.com/v1
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 subjects:
 - name: something

api/filters/patchstrategicmerge/patchstrategicmerge.go

@@ -18,7 +18,12 @@ var _ kio.Filter = Filter{}
 func (pf Filter) Filter(nodes []*yaml.RNode) ([]*yaml.RNode, error) {
 	var result []*yaml.RNode
 	for i := range nodes {
-		r, err := merge2.Merge(pf.Patch, nodes[i])
+		r, err := merge2.Merge(
+			pf.Patch, nodes[i],
+			yaml.MergeOptions{
+				ListIncreaseDirection: yaml.MergeOptionsListPrepend,
+			},
+		)
 		if err != nil {
 			return nil, err
 		}

api/filters/patchstrategicmerge/patchstrategicmerge_test.go

@@ -67,10 +67,10 @@ spec:
   template:
     spec:
       containers:
+      - name: foo0
       - name: foo1
       - name: foo2
       - name: foo3
-      - name: foo0
 `,
 		},
 		"volumes patch": {
@@ -107,10 +107,10 @@ spec:
   template:
     spec:
       volumes:
+      - name: foo0
       - name: foo1
       - name: foo2
       - name: foo3
-      - name: foo0
 `,
 		},
 		"nested patch": {
@@ -142,6 +142,441 @@ spec:
   - name: nginx
     args:
     - def
+`,
+		},
+		"remove mapping - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+        $patch: delete   
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers: []
+`,
+		},
+		"replace mapping - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      $patch: replace
+      containers:
+      - name: new
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: new
+`,
+		},
+		"merge mapping - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test1
+        $patch: merge   
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test1
+`,
+		},
+		"remove list - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - whatever
+      - $patch: delete
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec: {}
+`,
+		},
+		"replace list - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: replace
+        image: replace
+      - $patch: replace   
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: replace
+        image: replace
+`,
+		},
+		"merge list - directive": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+        image: test
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test2
+        image: test2
+      - $patch: merge   
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myDeploy
+spec:
+  template:
+    spec:
+      containers:
+      - name: test2
+        image: test2
+      - name: test
+        image: test
+`,
+		},
+		"list map keys - add a port, no names": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: TCP
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: UDP
+       - containerPort: 80
+         protocol: UDP
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: test-image
+        name: test-deployment
+        ports:
+        - containerPort: 8080
+          protocol: UDP
+        - containerPort: 80
+          protocol: UDP
+        - containerPort: 8080
+          protocol: TCP
+`,
+		},
+		"list map keys - add name to port": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: UDP
+       - containerPort: 8080
+         protocol: TCP
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: UDP
+         name: UDP-name-patch
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: test-image
+        name: test-deployment
+        ports:
+        - containerPort: 8080
+          protocol: UDP
+          name: UDP-name-patch
+        - containerPort: 8080
+          protocol: TCP
+`,
+		},
+		"list map keys - replace port name": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: UDP
+         name: UDP-name-original
+       - containerPort: 8080
+         protocol: TCP
+         name: TCP-name-original
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+         protocol: UDP
+         name: UDP-name-patch
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: test-image
+        name: test-deployment
+        ports:
+        - containerPort: 8080
+          protocol: UDP
+          name: UDP-name-patch
+        - containerPort: 8080
+          protocol: TCP
+          name: TCP-name-original
+`,
+		},
+		"list map keys - add a port, no protocol": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 8080
+`,
+			patch: yaml.MustParse(`
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: test-deployment
+spec:
+ template:
+   spec:
+     containers:
+     - image: test-image
+       name: test-deployment
+       ports:
+       - containerPort: 80
+`),
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-deployment
+spec:
+  template:
+    spec:
+      containers:
+      - image: test-image
+        name: test-deployment
+        ports:
+        - containerPort: 80
+        - containerPort: 8080
 `,
 		},
 	}

api/filters/refvar/refvar_test.go

@@ -188,6 +188,26 @@ data:
 				FieldSpec: types.FieldSpec{Path: "data/slice2"},
 			},
 		},
+		"null value": {
+			input: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+data:
+  FOO: null`,
+			expected: `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dep
+data:
+  FOO: null`,
+			filter: Filter{
+				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{}),
+				FieldSpec:   types.FieldSpec{Path: "data/FOO"},
+			},
+		},
 	}
 
 	for tn, tc := range testCases {
@@ -260,20 +280,6 @@ data:
 				FieldSpec: types.FieldSpec{Path: "data"},
 			},
 		},
-		"null input": {
-			input: `
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: dep
-data:
-  FOO: null`,
-			expectedError: "obj '' at path 'data/FOO': invalid type encountered 0",
-			filter: Filter{
-				MappingFunc: expansion2.MappingFuncFor(replacementCounts, map[string]interface{}{}),
-				FieldSpec:   types.FieldSpec{Path: "data/FOO"},
-			},
-		},
 	}
 
 	for tn, tc := range testCases {

api/go.mod

@@ -6,18 +6,19 @@ require (
 	github.com/evanphx/json-patch v4.5.0+incompatible
 	github.com/go-openapi/spec v0.19.5
 	github.com/golangci/golangci-lint v1.21.0
+	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/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.4.0
 	github.com/yujunz/go-getter v1.4.1-lite
-	golang.org/x/tools v0.0.0-20191010075000-0337d82405ff
+	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
 	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.5.0
+	sigs.k8s.io/kustomize/kyaml v0.9.4
 	sigs.k8s.io/yaml v1.2.0
 )
-
-replace sigs.k8s.io/kustomize/kyaml v0.5.0 => ../kyaml

api/go.sum

@@ -232,8 +232,12 @@ github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:Fecb
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
 github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g4TbElacI=
+github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
 github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
 github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
 github.com/hashicorp/go-version v1.1.0 h1:bPIoEKD27tNdebFGGxxYwcL4nepeY4j1QP23PFRGzg0=
@@ -307,6 +311,8 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
+github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0=
+github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4=
 github.com/mozilla/tls-observatory v0.0.0-20190404164649-a3c1b6cfecfd/go.mod h1:SrKMQvPiws7F7iqYp8/TX+IhxCYhzr6N/1yb8cwHsGk=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -526,6 +532,8 @@ golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20190930201159-7c411dea38b0/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191010075000-0337d82405ff h1:XdBG6es/oFDr1HwaxkxgVve7NB281QhxgK/i4voubFs=
 golang.org/x/tools v0.0.0-20191010075000-0337d82405ff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e h1:aZzprAO9/8oim3qStq3wc1Xuxx4QmAGriC4VU4ojemQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
@@ -584,6 +592,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.9.4 h1:DDuzZtjIzFqp2IPy4DTyCI69Cl3bDgcJODjI6sjF9NY=
+sigs.k8s.io/kustomize/kyaml v0.9.4/go.mod h1:UTm64bSWVdBUA8EQoYCxVOaBQxUdIOr5LKWxA4GNbkw=
 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

@@ -38,8 +38,7 @@ type Loader interface {
 	Cleanup() error
 }
 
-// Kunstructured allows manipulation of k8s objects
-// that do not have Golang structs.
+// Kunstructured represents a Kubernetes Resource Model object.
 type Kunstructured interface {
 	// Several uses.
 	Copy() Kunstructured

api/internal/accumulator/namereferencetransformer_test.go

@@ -789,9 +789,9 @@ func TestNameReferenceClusterWide(t *testing.T) {
 				"name": modifiedname,
 			},
 			"roleRef": map[string]interface{}{
-				"apiVersion": "rbac.authorization.k8s.io/v1",
-				"kind":       "ClusterRole",
-				"name":       orgname,
+				"apiGroup": "rbac.authorization.k8s.io",
+				"kind":     "ClusterRole",
+				"name":     orgname,
 			},
 			"subjects": []interface{}{
 				map[string]interface{}{
@@ -845,9 +845,9 @@ func TestNameReferenceClusterWide(t *testing.T) {
 					"name": modifiedname,
 				},
 				"roleRef": map[string]interface{}{
-					"apiVersion": "rbac.authorization.k8s.io/v1",
-					"kind":       "ClusterRole",
-					"name":       modifiedname,
+					"apiGroup": "rbac.authorization.k8s.io",
+					"kind":     "ClusterRole",
+					"name":     modifiedname,
 				},
 				// The following tests required a change in
 				// getNameFunc implementation in order to leverage
@@ -937,9 +937,9 @@ func TestNameReferenceNamespaceTransformation(t *testing.T) {
 				"name": modifiedname,
 			},
 			"roleRef": map[string]interface{}{
-				"apiVersion": "rbac.authorization.k8s.io/v1",
-				"kind":       "ClusterRole",
-				"name":       orgname,
+				"apiGroup": "rbac.authorization.k8s.io",
+				"kind":     "ClusterRole",
+				"name":     orgname,
 			},
 			"subjects": []interface{}{
 				map[string]interface{}{
@@ -973,9 +973,9 @@ func TestNameReferenceNamespaceTransformation(t *testing.T) {
 					"name": modifiedname,
 				},
 				"roleRef": map[string]interface{}{
-					"apiVersion": "rbac.authorization.k8s.io/v1",
-					"kind":       "ClusterRole",
-					"name":       modifiedname,
+					"apiGroup": "rbac.authorization.k8s.io",
+					"kind":     "ClusterRole",
+					"name":     modifiedname,
 				},
 				// The following tests required a change in
 				// getNameFunc implementation in order to leverage

api/internal/accumulator/refvartransformer_test.go

@@ -132,7 +132,7 @@ func TestRefVarTransformer(t *testing.T) {
 ' at path 'data/slice': invalid value type expect a string`,
 		},
 		{
-			description: "var replacement panic in nil",
+			description: "var replacement in nil",
 			given: given{
 				varMap: map[string]interface{}{},
 				fs: []types.FieldSpec{
@@ -150,7 +150,19 @@ func TestRefVarTransformer(t *testing.T) {
 							"nil": nil, // noticeably *not* a []string
 						}}).ResMap(),
 			},
-			errMessage: `obj '' at path 'data/nil': invalid type encountered 0`,
+			expected: expected{
+				res: resmaptest_test.NewRmBuilder(
+					t, resource.NewFactory(kunstruct.NewKunstructuredFactoryImpl())).
+					Add(map[string]interface{}{
+						"apiVersion": "v1",
+						"kind":       "ConfigMap",
+						"metadata": map[string]interface{}{
+							"name": "cm1",
+						},
+						"data": map[string]interface{}{
+							"nil": nil, // noticeably *not* a []string
+						}}).ResMap(),
+			},
 		},
 	}
 

api/internal/crawl/README.md

@@ -217,7 +217,7 @@ overview of each component with the following sections going into more details.
 
 The overall structure is outlined in the following figure:
 ![overview](
-https://sigs.k8s.io/kustomize/internal/tools/pictures/sys_arch.png)
+https://github.com/kubernetes-sigs/kustomize/blob/master/api/internal/crawl/pictures/token_config.png)
 
 #### Crawler
 The leftmost component consists of a crawler with an http cache of GitHub

api/internal/crawl/go.sum

@@ -206,8 +206,10 @@ github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:Fecb
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
 github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
 github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
 github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
 github.com/hashicorp/go-version v1.1.0 h1:bPIoEKD27tNdebFGGxxYwcL4nepeY4j1QP23PFRGzg0=
@@ -271,6 +273,8 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
+github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0=
+github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4=
 github.com/mozilla/tls-observatory v0.0.0-20190404164649-a3c1b6cfecfd/go.mod h1:SrKMQvPiws7F7iqYp8/TX+IhxCYhzr6N/1yb8cwHsGk=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -338,6 +342,7 @@ github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DM
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48=
 github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 github.com/stretchr/testify v0.0.0-20151208002404-e3a8ff8ce365/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
@@ -469,6 +474,7 @@ golang.org/x/tools v0.0.0-20190719005602-e377ae9d6386/go.mod h1:jcCCGcm9btYwXyDq
 golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20190930201159-7c411dea38b0/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191010075000-0337d82405ff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
@@ -523,8 +529,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.5.0 h1:xufpSxgpugQxtd0aN1ZsWnr3Kj0fpAi7GN4dnEs4oPg=
-sigs.k8s.io/kustomize/kyaml v0.5.0/go.mod h1:bEzbO5pN9OvlEeCLvFHo8Pu7SA26Herc2m60UeWZBdI=
+sigs.k8s.io/kustomize/kyaml v0.9.4 h1:DDuzZtjIzFqp2IPy4DTyCI69Cl3bDgcJODjI6sjF9NY=
+sigs.k8s.io/kustomize/kyaml v0.9.4/go.mod h1:UTm64bSWVdBUA8EQoYCxVOaBQxUdIOr5LKWxA4GNbkw=
 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/git/cloner.go

@@ -27,9 +27,6 @@ func ClonerUsingGitExec(repoSpec *RepoSpec) error {
 		return err
 	}
 
-	if repoSpec.Ref == "" {
-		repoSpec.Ref = "master"
-	}
 	cmd := exec.Command(
 		gitProgram,
 		"clone",
@@ -45,28 +42,30 @@ func ClonerUsingGitExec(repoSpec *RepoSpec) error {
 			repoSpec.CloneSpec(), repoSpec.Dir.String())
 	}
 
-	cmd = exec.Command(
-		gitProgram,
-		"fetch",
-		"--depth=1",
-		"origin",
-		repoSpec.Ref)
-	cmd.Dir = repoSpec.Dir.String()
-	out, err = cmd.CombinedOutput()
-	if err != nil {
-		log.Printf("Error fetching ref: %s", out)
-		return errors.Wrapf(err, "trouble fetching %s", repoSpec.Ref)
-	}
+	if repoSpec.Ref != "" {
+		cmd = exec.Command(
+			gitProgram,
+			"fetch",
+			"--depth=1",
+			"origin",
+			repoSpec.Ref)
+		cmd.Dir = repoSpec.Dir.String()
+		out, err = cmd.CombinedOutput()
+		if err != nil {
+			log.Printf("Error fetching ref: %s", out)
+			return errors.Wrapf(err, "trouble fetching %s", repoSpec.Ref)
+		}
 
-	cmd = exec.Command(
-		gitProgram,
-		"checkout",
-		"FETCH_HEAD")
-	cmd.Dir = repoSpec.Dir.String()
-	out, err = cmd.CombinedOutput()
-	if err != nil {
-		log.Printf("Error checking out ref: %s", out)
-		return errors.Wrapf(err, "trouble checking out %s", repoSpec.Ref)
+		cmd = exec.Command(
+			gitProgram,
+			"checkout",
+			"FETCH_HEAD")
+		cmd.Dir = repoSpec.Dir.String()
+		out, err = cmd.CombinedOutput()
+		if err != nil {
+			log.Printf("Error checking out ref: %s", out)
+			return errors.Wrapf(err, "trouble checking out %s", repoSpec.Ref)
+		}
 	}
 
 	cmd = exec.Command(

api/internal/merge/merginator.go

@@ -0,0 +1,25 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package merge
+
+import (
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
+)
+
+// Merginator implements resmap.Merginator using kyaml libs.
+type Merginator struct {
+}
+
+var _ resmap.Merginator = (*Merginator)(nil)
+
+func NewMerginator(_ *resource.Factory) *Merginator {
+	return &Merginator{}
+}
+
+// Merge implements resmap.Merginator
+func (m Merginator) Merge(
+	resources []*resource.Resource) (resmap.ResMap, error) {
+	panic("TODO(#Merginator): implement Merge")
+}

api/internal/merge/merginator_test.go

@@ -0,0 +1,4 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package merge_test

api/internal/plugins/builtinhelpers/builtinplugintype_string.go

@@ -23,11 +23,12 @@ func _() {
 	_ = x[ReplicaCountTransformer-12]
 	_ = x[SecretGenerator-13]
 	_ = x[ValueAddTransformer-14]
+	_ = x[HelmChartInflationGenerator-15]
 }
 
-const _BuiltinPluginType_name = "UnknownAnnotationsTransformerConfigMapGeneratorHashTransformerImageTagTransformerLabelTransformerLegacyOrderTransformerNamespaceTransformerPatchJson6902TransformerPatchStrategicMergeTransformerPatchTransformerPrefixSuffixTransformerReplicaCountTransformerSecretGeneratorValueAddTransformer"
+const _BuiltinPluginType_name = "UnknownAnnotationsTransformerConfigMapGeneratorHashTransformerImageTagTransformerLabelTransformerLegacyOrderTransformerNamespaceTransformerPatchJson6902TransformerPatchStrategicMergeTransformerPatchTransformerPrefixSuffixTransformerReplicaCountTransformerSecretGeneratorValueAddTransformerHelmChartInflationGenerator"
 
-var _BuiltinPluginType_index = [...]uint16{0, 7, 29, 47, 62, 81, 97, 119, 139, 163, 193, 209, 232, 255, 270, 289}
+var _BuiltinPluginType_index = [...]uint16{0, 7, 29, 47, 62, 81, 97, 119, 139, 163, 193, 209, 232, 255, 270, 289, 316}
 
 func (i BuiltinPluginType) String() string {
 	if i < 0 || i >= BuiltinPluginType(len(_BuiltinPluginType_index)-1) {

api/internal/plugins/builtinhelpers/builtins.go

@@ -27,6 +27,7 @@ const (
 	ReplicaCountTransformer
 	SecretGenerator
 	ValueAddTransformer
+	HelmChartInflationGenerator
 )
 
 var stringToBuiltinPluginTypeMap map[string]BuiltinPluginType
@@ -55,8 +56,9 @@ func GetBuiltinPluginType(n string) BuiltinPluginType {
 }
 
 var GeneratorFactories = map[BuiltinPluginType]func() resmap.GeneratorPlugin{
-	ConfigMapGenerator: builtins.NewConfigMapGeneratorPlugin,
-	SecretGenerator:    builtins.NewSecretGeneratorPlugin,
+	ConfigMapGenerator:          builtins.NewConfigMapGeneratorPlugin,
+	SecretGenerator:             builtins.NewSecretGeneratorPlugin,
+	HelmChartInflationGenerator: builtins.NewHelmChartInflationGeneratorPlugin,
 }
 
 var TransformerFactories = map[BuiltinPluginType]func() resmap.TransformerPlugin{

api/internal/plugins/doc.go

@@ -94,7 +94,7 @@ TO GENERATE CODE
   cd $repo/plugin/builtin
   go generate ./...
 
-See travis/kyaml-pre-commit.sh for canonical way
+See scripts/kyaml-pre-commit.sh for canonical way
 to execute the above.
 
 This creates

api/internal/plugins/execplugin/execplugin.go

@@ -9,6 +9,7 @@ import (
 	"io/ioutil"
 	"os"
 	"os/exec"
+	"runtime"
 	"strings"
 
 	"github.com/google/shlex"
@@ -50,7 +51,14 @@ func (p *ExecPlugin) ErrIfNotExecutable() error {
 	if err != nil {
 		return err
 	}
-	if f.Mode()&0111 == 0000 {
+	// In Windows, it is not possible to determine whether a
+	// file is executable through file mode.
+	// TODO: provide for setting the executable FileMode bit on Windows
+	// The (fs *fileStat) Mode() (m FileMode) {} function in
+	// https://golang.org/src/os/types_windows.go
+	// lacks the ability to set the FileMode executable bit in response
+	// to file data on Windows.
+	if f.Mode()&0111 == 0000 && runtime.GOOS != "windows" {
 		return fmt.Errorf("unexecutable plugin at: %s", p.path)
 	}
 	return nil

api/internal/plugins/execplugin/execplugin_test.go

@@ -4,12 +4,15 @@
 package execplugin_test
 
 import (
+	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 
 	"sigs.k8s.io/kustomize/api/filesys"
 	. "sigs.k8s.io/kustomize/api/internal/plugins/execplugin"
 	pLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
+	"sigs.k8s.io/kustomize/api/internal/plugins/utils"
 	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
 	"sigs.k8s.io/kustomize/api/konfig"
 	fLdr "sigs.k8s.io/kustomize/api/loader"
@@ -89,3 +92,32 @@ metadata:
 		t.Fatalf("unexpected arg array: %#v", p.Args())
 	}
 }
+
+func TestExecPlugin_ErrIfNotExecutable(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skipf("always returns nil on Windows")
+	}
+
+	srcRoot, err := utils.DeterminePluginSrcRoot(filesys.MakeFsOnDisk())
+	if err != nil {
+		t.Error(err)
+	}
+
+	// Test unexecutable plugin
+	unexecutablePlugin := filepath.Join(
+		srcRoot, "builtin", "", "secretgenerator", "SecretGenerator.so")
+	p := NewExecPlugin(unexecutablePlugin)
+	err = p.ErrIfNotExecutable()
+	if err == nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+
+	// Test executable plugin
+	executablePlugin := filepath.Join(
+		srcRoot, "someteam.example.com", "v1", "bashedconfigmap", "BashedConfigMap")
+	p = NewExecPlugin(executablePlugin)
+	err = p.ErrIfNotExecutable()
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+}

api/internal/plugins/fnplugin/fnplugin.go

@@ -74,10 +74,10 @@ func NewFnPlugin(o *types.FnPluginLoadingOptions) *FnPlugin {
 		runFns: runfn.RunFns{
 			Functions:      []*yaml.RNode{},
 			Network:        o.Network,
-			NetworkName:    o.NetworkName,
 			EnableStarlark: o.EnableStar,
 			EnableExec:     o.EnableExec,
 			StorageMounts:  toStorageMounts(o.Mounts),
+			Env:            o.Env,
 		},
 	}
 }

api/internal/plugins/loader/loader_test.go

@@ -65,8 +65,8 @@ func TestLoader(t *testing.T) {
 		t.Fatal(err)
 	}
 	for _, behavior := range []types.BuiltinPluginLoadingOptions{
-		types.BploUseStaticallyLinked,
-		types.BploLoadFromFileSys} {
+		/* types.BploUseStaticallyLinked,
+		types.BploLoadFromFileSys */} {
 		c, err := konfig.EnabledPluginConfig(behavior)
 		if err != nil {
 			t.Fatal(err)

api/internal/target/kusttarget.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hashicorp/go-multierror"
 	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/builtins"
 	"sigs.k8s.io/kustomize/api/ifc"
@@ -313,12 +314,18 @@ func (kt *KustTarget) accumulateResources(
 		if errF := kt.accumulateFile(ra, path); errF != nil {
 			ldr, errL := kt.ldr.New(path)
 			if errL != nil {
-				return nil, fmt.Errorf("accumulateFile %q, loader.New %q", errF, errL)
+				return nil, multierror.Append(
+					fmt.Errorf("accumulateFile error: %q", errF),
+					fmt.Errorf("loader.New error: %q", errL),
+				)
 			}
 			var errD error
 			ra, errD = kt.accumulateDirectory(ra, ldr, false)
 			if errD != nil {
-				return nil, fmt.Errorf("accumulateFile %q, accumulateDirector: %q", errF, errD)
+				return nil, multierror.Append(
+					fmt.Errorf("accumulateFile error: %q", errF),
+					fmt.Errorf("accumulateDirector error: %q", errD),
+				)
 			}
 		}
 	}

api/internal/target/kusttarget_configplugin.go

@@ -32,6 +32,7 @@ func (kt *KustTarget) configureBuiltinGenerators() (
 	for _, bpt := range []builtinhelpers.BuiltinPluginType{
 		builtinhelpers.ConfigMapGenerator,
 		builtinhelpers.SecretGenerator,
+		builtinhelpers.HelmChartInflationGenerator,
 	} {
 		r, err := generatorConfigurators[bpt](
 			kt, bpt, builtinhelpers.GeneratorFactories[bpt])
@@ -110,6 +111,23 @@ var generatorConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 		}
 		return
 	},
+
+	builtinhelpers.HelmChartInflationGenerator: func(kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f gFactory) (
+		result []resmap.Generator, err error) {
+		var c struct {
+			types.HelmChartArgs
+		}
+		for _, args := range kt.kustomization.HelmChartInflationGenerator {
+			c.HelmChartArgs = args
+			p := f()
+			err := kt.configureBuiltinPlugin(p, c, bpt)
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, p)
+		}
+		return
+	},
 }
 
 type tFactory func() resmap.TransformerPlugin
@@ -141,12 +159,12 @@ var transformerConfigurators = map[builtinhelpers.BuiltinPluginType]func(
 		kt *KustTarget, bpt builtinhelpers.BuiltinPluginType, f tFactory, _ *builtinconfig.TransformerConfig) (
 		result []resmap.Transformer, err error) {
 		var c struct {
-			Target types.PatchTarget `json:"target,omitempty" yaml:"target,omitempty"`
-			Path   string            `json:"path,omitempty" yaml:"path,omitempty"`
-			JsonOp string            `json:"jsonOp,omitempty" yaml:"jsonOp,omitempty"`
+			Target *types.Selector `json:"target,omitempty" yaml:"target,omitempty"`
+			Path   string          `json:"path,omitempty" yaml:"path,omitempty"`
+			JsonOp string          `json:"jsonOp,omitempty" yaml:"jsonOp,omitempty"`
 		}
 		for _, args := range kt.kustomization.PatchesJson6902 {
-			c.Target = *args.Target
+			c.Target = args.Target
 			c.Path = args.Path
 			c.JsonOp = args.Patch
 			p := f()

api/internal/target/multitransformer.go

@@ -26,13 +26,15 @@ func newMultiTransformer(t []resmap.Transformer) resmap.Transformer {
 	return r
 }
 
-// Transform prepends the name prefix.
+// Transform applies the member transformers in order to the resources,
+// optionally detecting and erroring on commutation conflict.
 func (o *multiTransformer) Transform(m resmap.ResMap) error {
 	if o.checkConflictEnabled {
 		return o.transformWithCheckConflict(m)
 	}
 	return o.transform(m)
 }
+
 func (o *multiTransformer) transform(m resmap.ResMap) error {
 	for _, t := range o.transformers {
 		err := t.Transform(m)

api/internal/tools/tools.go

@@ -21,5 +21,5 @@ import (
 	// major version increments in pluginator with each
 	// api release to allow this trick to work and not
 	// introduce cycles.
-	// _ "sigs.k8s.io/kustomize/pluginator/v2"
+	// _ "sigs.k8s.io/kustomize/cmd/pluginator/v2"
 )

api/internal/validate/fieldvalidator.go

@@ -0,0 +1,64 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package validate
+
+import (
+	"sigs.k8s.io/kustomize/api/ifc"
+)
+
+// FieldValidator implements ifc.Validator to check
+// the values of various KRM string fields,
+// e.g. labels, annotations, names, namespaces.
+type FieldValidator struct {
+}
+
+var _ ifc.Validator = (*FieldValidator)(nil)
+
+func NewFieldValidator() *FieldValidator {
+	return &FieldValidator{}
+}
+
+// TODO(#FieldValidator): implement MakeAnnotationValidator
+func (f FieldValidator) MakeAnnotationValidator() func(map[string]string) error {
+	return func(x map[string]string) error {
+		return nil
+	}
+}
+
+// TODO(#FieldValidator): implement MakeAnnotationNameValidator
+func (f FieldValidator) MakeAnnotationNameValidator() func([]string) error {
+	return func(x []string) error {
+		return nil
+	}
+}
+
+// TODO(#FieldValidator): implement MakeLabelValidator
+func (f FieldValidator) MakeLabelValidator() func(map[string]string) error {
+	return func(x map[string]string) error {
+		return nil
+	}
+}
+
+// TODO(#FieldValidator): implement MakeLabelNameValidator
+func (f FieldValidator) MakeLabelNameValidator() func([]string) error {
+	return func(x []string) error {
+		return nil
+	}
+}
+
+// TODO(#FieldValidator): implement ValidateNamespace
+func (f FieldValidator) ValidateNamespace(s string) []string {
+	var errs []string
+	return errs
+}
+
+// TODO(#FieldValidator): implement ErrIfInvalidKey
+func (f FieldValidator) ErrIfInvalidKey(s string) error {
+	return nil
+}
+
+// TODO(#FieldValidator): implement IsEnvVarName
+func (f FieldValidator) IsEnvVarName(k string) error {
+	return nil
+}

api/internal/validate/fieldvalidator_test.go

@@ -0,0 +1,4 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package validate_test

api/internal/wrappy/factory.go

@@ -0,0 +1,41 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package wrappy
+
+import (
+	"sigs.k8s.io/kustomize/api/ifc"
+	"sigs.k8s.io/kustomize/api/types"
+)
+
+// WNodeFactory makes instances of WNode.
+// These instances in turn adapt
+//   sigs.k8s.io/kustomize/kyaml/yaml.RNode
+// to implement ifc.Unstructured.
+// This factory is meant to implement ifc.KunstructuredFactory.
+type WNodeFactory struct {
+}
+
+var _ ifc.KunstructuredFactory = (*WNodeFactory)(nil)
+
+func (k *WNodeFactory) SliceFromBytes(bs []byte) ([]ifc.Kunstructured, error) {
+	panic("TODO(#WNodeFactory): implement SliceFromBytes")
+}
+
+func (k *WNodeFactory) FromMap(m map[string]interface{}) ifc.Kunstructured {
+	panic("TODO(#WNodeFactory): implement FromMap")
+}
+
+func (k *WNodeFactory) Hasher() ifc.KunstructuredHasher {
+	panic("TODO(#WNodeFactory): implement Hasher")
+}
+
+func (k *WNodeFactory) MakeConfigMap(
+	kvLdr ifc.KvLoader, args *types.ConfigMapArgs) (ifc.Kunstructured, error) {
+	panic("TODO(#WNodeFactory): implement MakeConfigMap")
+}
+
+func (k *WNodeFactory) MakeSecret(
+	kvLdr ifc.KvLoader, args *types.SecretArgs) (ifc.Kunstructured, error) {
+	panic("TODO(#WNodeFactory): implement MakeSecret")
+}

api/internal/wrappy/factory_test.go

@@ -0,0 +1,4 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package wrappy

api/internal/wrappy/wnode.go

@@ -0,0 +1,215 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package wrappy
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"sigs.k8s.io/kustomize/api/ifc"
+	"sigs.k8s.io/kustomize/api/resid"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
+)
+
+// WNode implements ifc.Kunstructured using yaml.RNode.
+//
+// It exists only to help manage a switch from
+// kunstruct.UnstructAdapter to yaml.RNode as the core
+// representation of KRM objects in kustomize.
+//
+// It's got a silly name because we don't want it around for long,
+// and want its use to be obvious.
+type WNode struct {
+	node *yaml.RNode
+}
+
+var _ ifc.Kunstructured = (*WNode)(nil)
+
+func NewWNode() *WNode {
+	return FromRNode(yaml.NewRNode(nil))
+}
+
+func FromRNode(node *yaml.RNode) *WNode {
+	return &WNode{node: node}
+}
+
+func (wn *WNode) demandMetaData(label string) yaml.ResourceMeta {
+	meta, err := wn.node.GetMeta()
+	if err != nil {
+		// Log and die since interface doesn't allow error.
+		log.Fatalf("for %s', expected valid resource: %v", label, err)
+	}
+	return meta
+}
+
+// Copy implements ifc.Kunstructured.
+func (wn *WNode) Copy() ifc.Kunstructured {
+	return &WNode{node: wn.node.Copy()}
+}
+
+// GetAnnotations implements ifc.Kunstructured.
+func (wn *WNode) GetAnnotations() map[string]string {
+	return wn.demandMetaData("GetAnnotations").Annotations
+}
+
+// GetFieldValue implements ifc.Kunstructured.
+func (wn *WNode) GetFieldValue(path string) (interface{}, error) {
+	fields := strings.Split(path, ".")
+	rn, err := wn.node.Pipe(yaml.Lookup(fields...))
+	if err != nil {
+		return nil, err
+	}
+	if rn == nil {
+		return nil, NoFieldError{path}
+	}
+	yn := rn.YNode()
+
+	// If this is an alias node, resolve it
+	if yn.Kind == yaml.AliasNode {
+		yn = yn.Alias
+	}
+
+	// Return value as map for DocumentNode and MappingNode kinds
+	if yn.Kind == yaml.DocumentNode || yn.Kind == yaml.MappingNode {
+		var result map[string]interface{}
+		if err := yn.Decode(&result); err != nil {
+			return nil, err
+		}
+		return result, err
+	}
+
+	// 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)
+		}
+		return result, nil
+	}
+
+	// Return value value directly for all other (ScalarNode) kinds
+	return yn.Value, nil
+}
+
+// GetGvk implements ifc.Kunstructured.
+func (wn *WNode) GetGvk() resid.Gvk {
+	meta := wn.demandMetaData("GetGvk")
+	g, v := resid.ParseGroupVersion(meta.APIVersion)
+	return resid.Gvk{Group: g, Version: v, Kind: meta.Kind}
+}
+
+// GetKind implements ifc.Kunstructured.
+func (wn *WNode) GetKind() string {
+	return wn.demandMetaData("GetKind").Kind
+}
+
+// GetLabels implements ifc.Kunstructured.
+func (wn *WNode) GetLabels() map[string]string {
+	return wn.demandMetaData("GetLabels").Labels
+}
+
+// GetName implements ifc.Kunstructured.
+func (wn *WNode) GetName() string {
+	return wn.demandMetaData("GetName").Name
+}
+
+// GetSlice implements ifc.Kunstructured.
+func (wn *WNode) GetSlice(path string) ([]interface{}, error) {
+	value, err := wn.GetFieldValue(path)
+	if err != nil {
+		return nil, err
+	}
+	if sliceValue, ok := value.([]interface{}); ok {
+		return sliceValue, nil
+	}
+	return nil, fmt.Errorf("node %s is not a slice", path)
+}
+
+// GetSlice implements ifc.Kunstructured.
+func (wn *WNode) GetString(path string) (string, error) {
+	value, err := wn.GetFieldValue(path)
+	if err != nil {
+		return "", err
+	}
+	if v, ok := value.(string); ok {
+		return v, nil
+	}
+	return "", fmt.Errorf("node %s is not a string: %v", path, value)
+}
+
+// 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
+}
+
+// MarshalJSON implements ifc.Kunstructured.
+func (wn *WNode) MarshalJSON() ([]byte, error) {
+	return wn.node.MarshalJSON()
+}
+
+// MatchesAnnotationSelector implements ifc.Kunstructured.
+func (wn *WNode) MatchesAnnotationSelector(string) (bool, error) {
+	panic("TODO(#WNode) MatchesAnnotationSelector; implement or drop from API")
+}
+
+// MatchesLabelSelector implements ifc.Kunstructured.
+func (wn *WNode) MatchesLabelSelector(string) (bool, error) {
+	panic("TODO(#WNode) MatchesLabelSelector; implement or drop from API")
+}
+
+// SetAnnotations implements ifc.Kunstructured.
+func (wn *WNode) SetAnnotations(annotations map[string]string) {
+	wn.setField(yaml.NewMapRNode(&annotations), yaml.MetadataField, yaml.AnnotationsField)
+}
+
+// SetGvk implements ifc.Kunstructured.
+func (wn *WNode) SetGvk(gvk resid.Gvk) {
+	wn.setField(yaml.NewScalarRNode(gvk.Kind), yaml.KindField)
+	wn.setField(yaml.NewScalarRNode(fmt.Sprintf("%s/%s", gvk.Group, gvk.Version)), yaml.APIVersionField)
+}
+
+// SetLabels implements ifc.Kunstructured.
+func (wn *WNode) SetLabels(labels map[string]string) {
+	wn.setField(yaml.NewMapRNode(&labels), yaml.MetadataField, yaml.LabelsField)
+}
+
+// SetName implements ifc.Kunstructured.
+func (wn *WNode) SetName(name string) {
+	wn.setField(yaml.NewScalarRNode(name), yaml.MetadataField, yaml.NameField)
+}
+
+// SetNamespace implements ifc.Kunstructured.
+func (wn *WNode) SetNamespace(ns string) {
+	wn.setField(yaml.NewScalarRNode(ns), yaml.MetadataField, yaml.NamespaceField)
+}
+
+func (wn *WNode) setField(value *yaml.RNode, path ...string) {
+	err := wn.node.PipeE(
+		yaml.LookupCreate(yaml.MappingNode, path[0:len(path)-1]...),
+		yaml.SetField(path[len(path)-1], value),
+	)
+	if err != nil {
+		// Log and die since interface doesn't allow error.
+		log.Fatalf("failed to set field %v: %v", path, err)
+	}
+}
+
+// UnmarshalJSON implements ifc.Kunstructured.
+func (wn *WNode) UnmarshalJSON(data []byte) error {
+	return wn.node.UnmarshalJSON(data)
+}
+
+type NoFieldError struct {
+	Field string
+}
+
+func (e NoFieldError) Error() string {
+	return fmt.Sprintf("no field named '%s'", e.Field)
+}

api/internal/wrappy/wnode_test.go

@@ -0,0 +1,553 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package wrappy
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"sigs.k8s.io/kustomize/api/resid"
+
+	"gopkg.in/yaml.v3"
+	kyaml "sigs.k8s.io/kustomize/kyaml/yaml"
+)
+
+const (
+	deploymentLittleJson = `{"apiVersion":"apps/v1","kind":"Deployment",` +
+		`"metadata":{"name":"homer","namespace":"simpsons"}}`
+
+	deploymentBiggerJson = `
+{
+  "apiVersion": "apps/v1",
+  "kind": "Deployment",
+  "metadata": {
+    "name": "homer",
+    "namespace": "simpsons",
+    "labels": {
+      "fruit": "apple",
+      "veggie": "carrot"
+    },
+    "annotations": {
+      "area": "51",
+      "greeting": "Take me to your leader."
+    }
+  }
+}
+`
+	bigMapYaml = `Kind: Service
+complextree:
+  - field1:
+      - boolfield: true
+        floatsubfield: 1.01
+        intsubfield: 1010
+        stringsubfield: idx1010
+      - boolfield: false
+        floatsubfield: 1.011
+        intsubfield: 1011
+        stringsubfield: idx1011
+    field2:
+      - boolfield: true
+        floatsubfield: 1.02
+        intsubfield: 1020
+        stringsubfield: idx1020
+      - boolfield: false
+        floatsubfield: 1.021
+        intsubfield: 1021
+        stringsubfield: idx1021
+  - field1:
+      - boolfield: true
+        floatsubfield: 1.11
+        intsubfield: 1110
+        stringsubfield: idx1110
+      - boolfield: false
+        floatsubfield: 1.111
+        intsubfield: 1111
+        stringsubfield: idx1111
+    field2:
+      - boolfield: true
+        floatsubfield: 1.112
+        intsubfield: 1120
+        stringsubfield: idx1120
+      - boolfield: false
+        floatsubfield: 1.1121
+        intsubfield: 1121
+        stringsubfield: idx1121
+metadata:
+    labels:
+        app: application-name
+    name: service-name
+spec:
+    ports:
+        port: 80
+that:
+  - idx0
+  - idx1
+  - idx2
+  - idx3
+these:
+  - field1:
+      - idx010
+      - idx011
+    field2:
+      - idx020
+      - idx021
+  - field1:
+      - idx110
+      - idx111
+    field2:
+      - idx120
+      - idx121
+  - field1:
+      - idx210
+      - idx211
+    field2:
+      - idx220
+      - idx221
+this:
+    is:
+        aBool: true
+        aFloat: 1.001
+        aNilValue: null
+        aNumber: 1000
+        anEmptyMap: {}
+        anEmptySlice: []
+those:
+  - field1: idx0foo
+    field2: idx0bar
+  - field1: idx1foo
+    field2: idx1bar
+  - field1: idx2foo
+    field2: idx2bar
+`
+)
+
+func makeBigMap() map[string]interface{} {
+	return map[string]interface{}{
+		"Kind": "Service",
+		"metadata": map[string]interface{}{
+			"labels": map[string]interface{}{
+				"app": "application-name",
+			},
+			"name": "service-name",
+		},
+		"spec": map[string]interface{}{
+			"ports": map[string]interface{}{
+				"port": int64(80),
+			},
+		},
+		"this": map[string]interface{}{
+			"is": map[string]interface{}{
+				"aNumber":      int64(1000),
+				"aFloat":       float64(1.001),
+				"aNilValue":    nil,
+				"aBool":        true,
+				"anEmptyMap":   map[string]interface{}{},
+				"anEmptySlice": []interface{}{},
+				/*
+					TODO: test for unrecognizable (e.g. a function)
+						"unrecognizable": testing.InternalExample{
+							Name: "fooBar",
+						},
+				*/
+			},
+		},
+		"that": []interface{}{
+			"idx0",
+			"idx1",
+			"idx2",
+			"idx3",
+		},
+		"those": []interface{}{
+			map[string]interface{}{
+				"field1": "idx0foo",
+				"field2": "idx0bar",
+			},
+			map[string]interface{}{
+				"field1": "idx1foo",
+				"field2": "idx1bar",
+			},
+			map[string]interface{}{
+				"field1": "idx2foo",
+				"field2": "idx2bar",
+			},
+		},
+		"these": []interface{}{
+			map[string]interface{}{
+				"field1": []interface{}{"idx010", "idx011"},
+				"field2": []interface{}{"idx020", "idx021"},
+			},
+			map[string]interface{}{
+				"field1": []interface{}{"idx110", "idx111"},
+				"field2": []interface{}{"idx120", "idx121"},
+			},
+			map[string]interface{}{
+				"field1": []interface{}{"idx210", "idx211"},
+				"field2": []interface{}{"idx220", "idx221"},
+			},
+		},
+		"complextree": []interface{}{
+			map[string]interface{}{
+				"field1": []interface{}{
+					map[string]interface{}{
+						"stringsubfield": "idx1010",
+						"intsubfield":    int64(1010),
+						"floatsubfield":  float64(1.010),
+						"boolfield":      true,
+					},
+					map[string]interface{}{
+						"stringsubfield": "idx1011",
+						"intsubfield":    int64(1011),
+						"floatsubfield":  float64(1.011),
+						"boolfield":      false,
+					},
+				},
+				"field2": []interface{}{
+					map[string]interface{}{
+						"stringsubfield": "idx1020",
+						"intsubfield":    int64(1020),
+						"floatsubfield":  float64(1.020),
+						"boolfield":      true,
+					},
+					map[string]interface{}{
+						"stringsubfield": "idx1021",
+						"intsubfield":    int64(1021),
+						"floatsubfield":  float64(1.021),
+						"boolfield":      false,
+					},
+				},
+			},
+			map[string]interface{}{
+				"field1": []interface{}{
+					map[string]interface{}{
+						"stringsubfield": "idx1110",
+						"intsubfield":    int64(1110),
+						"floatsubfield":  float64(1.110),
+						"boolfield":      true,
+					},
+					map[string]interface{}{
+						"stringsubfield": "idx1111",
+						"intsubfield":    int64(1111),
+						"floatsubfield":  float64(1.111),
+						"boolfield":      false,
+					},
+				},
+				"field2": []interface{}{
+					map[string]interface{}{
+						"stringsubfield": "idx1120",
+						"intsubfield":    int64(1120),
+						"floatsubfield":  float64(1.1120),
+						"boolfield":      true,
+					},
+					map[string]interface{}{
+						"stringsubfield": "idx1121",
+						"intsubfield":    int64(1121),
+						"floatsubfield":  float64(1.1121),
+						"boolfield":      false,
+					},
+				},
+			},
+		},
+	}
+}
+
+func TestBasicYamlOperationFromMap(t *testing.T) {
+	bytes, err := yaml.Marshal(makeBigMap())
+	if err != nil {
+		t.Fatalf("unexpected yaml.Marshal err: %v", err)
+	}
+	if string(bytes) != bigMapYaml {
+		t.Fatalf("unexpected string equality")
+	}
+	rNode, err := kyaml.Parse(string(bytes))
+	if err != nil {
+		t.Fatalf("unexpected yaml.Marshal err: %v", err)
+	}
+	rNodeString := rNode.MustString()
+	// The result from MustString has more indentation
+	// than bigMapYaml.
+	rNodeStrings := strings.Split(rNodeString, "\n")
+	bigMapStrings := strings.Split(bigMapYaml, "\n")
+	if len(rNodeStrings) != len(bigMapStrings) {
+		t.Fatalf("line count mismatch")
+	}
+	for i := range rNodeStrings {
+		s1 := strings.TrimSpace(rNodeStrings[i])
+		s2 := strings.TrimSpace(bigMapStrings[i])
+		if s1 != s2 {
+			t.Fatalf("expected '%s'=='%s'", s1, s2)
+		}
+	}
+}
+
+func TestRoundTripJSON(t *testing.T) {
+	wn := NewWNode()
+	err := wn.UnmarshalJSON([]byte(deploymentLittleJson))
+	if err != nil {
+		t.Fatalf("unexpected UnmarshalJSON err: %v", err)
+	}
+	data, err := wn.MarshalJSON()
+	if err != nil {
+		t.Fatalf("unexpected MarshalJSON err: %v", err)
+	}
+	actual := string(data)
+	if actual != deploymentLittleJson {
+		t.Fatalf("expected %s, got %s", deploymentLittleJson, actual)
+	}
+}
+
+func TestGettingFields(t *testing.T) {
+	wn := NewWNode()
+	err := wn.UnmarshalJSON([]byte(deploymentBiggerJson))
+	if err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	gvk := wn.GetGvk()
+	expected := "apps"
+	actual := gvk.Group
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	expected = "v1"
+	actual = gvk.Version
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	expected = "Deployment"
+	actual = gvk.Kind
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	actual = wn.GetKind()
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	expected = "homer"
+	actual = wn.GetName()
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	actualMap := wn.GetLabels()
+	v, ok := actualMap["fruit"]
+	if !ok || v != "apple" {
+		t.Fatalf("unexpected labels '%v'", actualMap)
+	}
+	actualMap = wn.GetAnnotations()
+	v, ok = actualMap["greeting"]
+	if !ok || v != "Take me to your leader." {
+		t.Fatalf("unexpected annotations '%v'", actualMap)
+	}
+}
+
+func TestGetFieldValueReturnsMap(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	expected := map[string]interface{}{
+		"fruit":  "apple",
+		"veggie": "carrot",
+	}
+	actual, err := wn.GetFieldValue("metadata.labels")
+	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)
+	}
+}
+
+func TestGetFieldValueReturnsSlice(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{}{"idx0", "idx1", "idx2", "idx3"}
+	actual, err := wn.GetFieldValue("that")
+	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 {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	actual, err := wn.GetFieldValue("metadata.labels.fruit")
+	if err != nil {
+		t.Fatalf("error getting field value: %v", err)
+	}
+	v, ok := actual.(string)
+	if !ok || v != "apple" {
+		t.Fatalf("unexpected value '%v'", actual)
+	}
+}
+
+func TestGetFieldValueResolvesAlias(t *testing.T) {
+	yamlWithAlias := `
+foo: &a theValue
+bar: *a
+`
+	rNode, err := kyaml.Parse(yamlWithAlias)
+	if err != nil {
+		t.Fatalf("unexpected yaml parse error: %v", err)
+	}
+	wn := FromRNode(rNode)
+	actual, err := wn.GetFieldValue("bar")
+	if err != nil {
+		t.Fatalf("error getting field value: %v", err)
+	}
+	v, ok := actual.(string)
+	if !ok || v != "theValue" {
+		t.Fatalf("unexpected value '%v'", actual)
+	}
+}
+
+func TestGetString(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	expected := "carrot"
+	actual, err := wn.GetString("metadata.labels.veggie")
+	if err != nil {
+		t.Fatalf("error getting string: %v", err)
+	}
+	if expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}
+
+func TestGetSlice(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{}{"idx0", "idx1", "idx2", "idx3"}
+	actual, err := wn.GetSlice("that")
+	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 TestMap(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentLittleJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+
+	expected := map[string]interface{}{
+		"apiVersion": "apps/v1",
+		"kind":       "Deployment",
+		"metadata": map[string]interface{}{
+			"name":      "homer",
+			"namespace": "simpsons",
+		},
+	}
+
+	actual := wn.Map()
+	if diff := cmp.Diff(expected, actual); diff != "" {
+		t.Fatalf("actual map does not deep equal expected map:\n%v", diff)
+	}
+}
+
+func TestSetName(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	wn.SetName("marge")
+	if expected, actual := "marge", wn.GetName(); expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}
+
+func TestSetNamespace(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	wn.SetNamespace("flanders")
+	meta, _ := wn.node.GetMeta()
+	if expected, actual := "flanders", meta.Namespace; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}
+
+func TestSetLabels(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	wn.SetLabels(map[string]string{
+		"label1": "foo",
+		"label2": "bar",
+	})
+	labels := wn.GetLabels()
+	if expected, actual := 2, len(labels); expected != actual {
+		t.Fatalf("expected '%d', got '%d'", expected, actual)
+	}
+	if expected, actual := "foo", labels["label1"]; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	if expected, actual := "bar", labels["label2"]; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}
+
+func TestGetAnnotations(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	wn.SetAnnotations(map[string]string{
+		"annotation1": "foo",
+		"annotation2": "bar",
+	})
+	annotations := wn.GetAnnotations()
+	if expected, actual := 2, len(annotations); expected != actual {
+		t.Fatalf("expected '%d', got '%d'", expected, actual)
+	}
+	if expected, actual := "foo", annotations["annotation1"]; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	if expected, actual := "bar", annotations["annotation2"]; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}
+
+func TestSetGvk(t *testing.T) {
+	wn := NewWNode()
+	if err := wn.UnmarshalJSON([]byte(deploymentBiggerJson)); err != nil {
+		t.Fatalf("unexpected unmarshaljson err: %v", err)
+	}
+	wn.SetGvk(resid.GvkFromString("grp_ver_knd"))
+	gvk := wn.GetGvk()
+	if expected, actual := "grp", gvk.Group; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	if expected, actual := "ver", gvk.Version; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+	if expected, actual := "knd", gvk.Kind; expected != actual {
+		t.Fatalf("expected '%s', got '%s'", expected, actual)
+	}
+}

api/k8sdeps/kunstruct/factory.go

@@ -17,7 +17,11 @@ import (
 	"sigs.k8s.io/kustomize/api/types"
 )
 
-// KunstructuredFactoryImpl hides construction using apimachinery types.
+// KunstructuredFactoryImpl makes instances of UnstructAdapter.
+// These instances in turn adapt structs in
+//   k8s.io/apimachinery/pkg/apis/meta/v1/unstructured
+// to implement ifc.Kunstructured.
+// This factory is meant to implement ifc.KunstructuredFactory.
 type KunstructuredFactoryImpl struct {
 	hasher *kustHash
 }

api/k8sdeps/validator/kustvalidator.go

@@ -14,11 +14,14 @@ import (
 	v1validation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
 	"k8s.io/apimachinery/pkg/util/validation"
 	"k8s.io/apimachinery/pkg/util/validation/field"
+	"sigs.k8s.io/kustomize/api/ifc"
 )
 
 // KustValidator validates Labels and annotations by apimachinery
 type KustValidator struct{}
 
+var _ ifc.Validator = (*KustValidator)(nil)
+
 // NewKustValidator returns a KustValidator object
 func NewKustValidator() *KustValidator {
 	return &KustValidator{}

api/konfig/builtinpluginconsts/namereference.go

@@ -238,6 +238,8 @@ nameReference:
     kind: Ingress
   - path: metadata/annotations/nginx.ingress.kubernetes.io\/auth-tls-secret
     kind: Ingress
+  - path: spec/tls/secretName
+    kind: Ingress
   - path: imagePullSecrets/name
     kind: ServiceAccount
   - path: parameters/secretName
@@ -267,6 +269,10 @@ nameReference:
     kind: Ingress
   - path: spec/backend/serviceName
     kind: Ingress
+  - path: spec/rules/http/paths/backend/service/name
+    kind: Ingress
+  - path: spec/defaultBackend/service/name
+    kind: Ingress
   - path: spec/service/name
     kind: APIService
     group: apiregistration.k8s.io
@@ -373,5 +379,12 @@ nameReference:
     kind: Job
   - path: spec/template/spec/priorityClassName
     kind: DaemonSet
+
+- kind: IngressClass
+  version: v1
+  group: networking.k8s.io/v1
+  fieldSpecs:
+  - path: spec/ingressClassName
+    kind: Ingress
 `
 )

api/konfig/builtinpluginconsts/namespace.go

@@ -8,6 +8,9 @@ const (
 namespace:
 - path: metadata/namespace
   create: true
+- path: metadata/name
+  kind: Namespace
+  create: true
 - path: subjects
   kind: RoleBinding
 - path: subjects

api/konfig/builtinpluginconsts/varreference.go

@@ -87,6 +87,9 @@ varReference:
 - path: spec/template/spec/volumes/nfs/server
   kind: Deployment
 
+- path: spec/template/metadata/annotations
+  kind: Deployment
+
 - path: spec/rules/host
   kind: Ingress
 

api/krusty/baseandoverlaymedium_test.go

@@ -225,13 +225,13 @@ spec:
     spec:
       containers:
       - env:
-        - name: foo
-          value: bar
         - name: FOO
           valueFrom:
             configMapKeyRef:
               key: somekey
               name: test-infra-app-env-8h5mh7f7ch
+        - name: foo
+          value: bar
         image: nginx:1.8.0
         name: nginx
         ports:

api/krusty/fnplugin_test.go

@@ -464,3 +464,50 @@ metadata:
   name: another-namespace
 `)
 }
+
+func TestFnContainerEnvVars(t *testing.T) {
+	skipIfNoDocker(t)
+
+	th := kusttest_test.MakeEnhancedHarness(t)
+	defer th.Reset()
+
+	th.WriteK("/app", `
+generators:
+- gener.yaml
+`)
+
+	// TODO: cheange image to gcr.io/kpt-functions/templater:stable
+	// when https://github.com/GoogleContainerTools/kpt-functions-catalog/pull/103
+	// is merged
+	th.WriteF("/app/gener.yaml", `
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: demo
+  annotations:
+    config.kubernetes.io/function: |
+      container:
+        image: quay.io/aodinokov/kpt-templater:0.0.1
+        envs:
+        - TESTTEMPLATE=value
+data:
+  template: |
+    apiVersion: v1
+    kind: ConfigMap
+    metadata:
+      name: env
+    data:
+      value: '{{ env "TESTTEMPLATE" }}'
+`)
+	m := th.Run("/app", th.MakeOptionsPluginsEnabled())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+data:
+  value: value
+kind: ConfigMap
+metadata:
+  annotations:
+    config.kubernetes.io/path: configmap_env.yaml
+  name: env
+`)
+}

api/krusty/generatormergeandreplace_test.go

@@ -385,12 +385,12 @@ spec:
       - gcePersistentDisk:
           pdName: nginx-persistent-storage
         name: nginx-persistent-storage
-      - configMap:
-          name: staging-team-foo-configmap-in-base-hc6g9dk6g9
-        name: configmap-in-base
       - configMap:
           name: staging-configmap-in-overlay-dc6fm46dhm
         name: configmap-in-overlay
+      - configMap:
+          name: staging-team-foo-configmap-in-base-hc6g9dk6g9
+        name: configmap-in-base
 ---
 apiVersion: v1
 kind: Service

api/krusty/helmchartinflationgenerator_test.go

@@ -0,0 +1,103 @@
+// 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"
+)
+
+var expected string = `
+apiVersion: v1
+data:
+  rcon-password: Q0hBTkdFTUUh
+kind: Secret
+metadata:
+  labels:
+    app: test-minecraft
+    chart: minecraft-1.2.0
+    heritage: Helm
+    release: test
+  name: test-minecraft
+type: Opaque
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  annotations:
+    volume.alpha.kubernetes.io/storage-class: default
+  labels:
+    app: test-minecraft
+    chart: minecraft-1.2.0
+    heritage: Helm
+    release: test
+  name: test-minecraft-datadir
+spec:
+  accessModes:
+  - ReadWriteOnce
+  resources:
+    requests:
+      storage: 1Gi
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app: test-minecraft
+    chart: minecraft-1.2.0
+    heritage: Helm
+    release: test
+  name: test-minecraft
+spec:
+  ports:
+  - name: minecraft
+    port: 25565
+    protocol: TCP
+    targetPort: minecraft
+  selector:
+    app: test-minecraft
+  type: LoadBalancer
+`
+
+func TestHelmChartInflationGenerator(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+helmChartInflationGenerator:
+- chartName: minecraft
+  chartRepoUrl: https://kubernetes-charts.storage.googleapis.com
+  chartVersion: v1.2.0
+  releaseName: test
+  releaseNamespace: testNamespace
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, expected)
+}
+
+
+func TestHelmChartInflationGeneratorAsPlugin(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+generators:
+- helm.yaml
+`)
+
+	th.WriteF("/app/helm.yaml", `
+apiVersion: builtin
+kind: HelmChartInflationGenerator
+metadata:
+  name: myMap
+chartName: minecraft
+chartRepoUrl: https://kubernetes-charts.storage.googleapis.com
+chartVersion: v1.2.0
+releaseName: test
+releaseNamespace: testNamespace
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, expected)
+}
+*/

api/krusty/internal/provider/depprovider.go

@@ -0,0 +1,183 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package provider
+
+import (
+	"sigs.k8s.io/kustomize/api/ifc"
+	"sigs.k8s.io/kustomize/api/internal/k8sdeps/merge"
+	kmerge "sigs.k8s.io/kustomize/api/internal/merge"
+	"sigs.k8s.io/kustomize/api/internal/validate"
+	"sigs.k8s.io/kustomize/api/internal/wrappy"
+	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
+	"sigs.k8s.io/kustomize/api/k8sdeps/validator"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
+)
+
+// DepProvider is a dependency provider.
+//
+// The instances it returns are either
+//   - old implementations backed by k8sdeps code,
+//   - new implementations backed by kyaml code.
+//
+// History:
+//
+// kubectl depends on k8s.io code, and at the time of writing, so
+// does kustomize.  Code that imports k8s.io/api* cannot be imported
+// back into k8s.io/*, yet kustomize appears inside k8s.io/kubectl.
+//
+// To allow kustomize to appear inside kubectl, yet still be developed
+// outside kubectl, the kustomize code was divided into the following
+// packages
+//
+//    api/
+//      k8sdeps/  (and internal/ks8deps/)
+//      ifc/
+//      krusty/
+//      everythingElse/
+//
+// with the following rules:
+//
+//   - Only k8sdeps/ may import k8s.io/api*.
+//
+//   - Only krusty/ (and its internals) may import k8sdeps/.
+//     I.e., ifc/ and everythingElse/ must not
+//     import k8sdeps/ or k8s.io/api*.
+//
+//   - Code in krusty/ may use code in k8sdeps/ to create
+//     objects then inject said objects into
+//     everythingElse/ behind dependency neutral interfaces.
+//
+// The idea was to periodically copy, not import, the large k8sdeps/
+// tree (plus a snippet from krusty/kustomizer.go) into the kubectl
+// codebase via a large PR, and have kubectl depend on the rest via
+// normal importing.
+//
+// Over 2019, however, kubectl underwent large changes including
+// a switch to Go modules, and a concerted attempt to extract kubectl
+// from the k8s repo. This made large kustomize integration PRs too
+// intrusive to review.
+//
+// In 2020, kubectl is based on Go modules, and almost entirely
+// extracted from the k8s.io repositories, and further the kyaml
+// library has a appeared as a viable replacement to k8s.io/api*
+// KRM manipulation code.
+//
+// The new plan is to eliminate k8sdeps/ entirely, along with its
+// k8s.io/api* dependence, allowing kustomize code to be imported
+// into kubectl via normal Go module imports.  Then the kustomize API
+// code can then move into the github.com/kubernetes-sigs/cli-utils
+// repo.  The kustomize CLI in github.com/kubernetes-sigs/kustomize
+// and the kubectl CLI can then both depend on the kustomize API.
+//
+// So, all code that depends on k8sdeps must go behind interfaces,
+// and kustomize must be factored to choose the implementation.
+//
+// That problem has been reduced to three interfaces, each having
+// two implementations. (1) is k8sdeps-based, (2) is kyaml-based.
+//
+//   - ifc.Kunstructured
+//
+//       1) api/k8sdeps/kunstruct.UnstructAdapter
+//
+//            This adapts structs in
+//            k8s.io/apimachinery/pkg/apis/meta/v1/unstructured
+//            to ifc.Kunstructured.
+//
+//       2) api/wrappy.WNode
+//
+//            This adapts sigs.k8s.io/kustomize/kyaml/yaml.RNode
+//            to ifc.Unstructured.
+//
+//            At time of writing, implementation started.
+//            Further reducing the size of ifc.Kunstructed
+//            would really reduce the work
+//            (e.g. drop Vars, drop ReplacementTranformer).
+//
+//   - resmap.Merginator
+//
+//       1) api/internal/k8sdeps/merge.Merginator
+//
+//            Uses k8s.io/apimachinery/pkg/util/strategicpatch,
+//            apimachinery/pkg/util/mergepatch, etc. to merge
+//            resource.Resource instances.
+//
+//       2) api/internal/merge.Merginator
+//
+//            At time of writing, this is unimplemented.
+//
+//   - ifc.Validator
+//
+//       1) api/k8sdeps/validator.KustValidator
+//
+//            Uses k8s.io/apimachinery/pkg/api/validation and
+//            friends to validate strings.
+//
+//       2) api/internal/validate.FieldValidator
+//
+//            At time of writing, this is a do-nothing
+//            validator as it's not critical to kustomize function.
+//
+// Proposed plan:
+//  [ ] Ship kustomize with the ability to switch from 1 to 2 via
+//      an --enable_kyaml flag.
+//  [ ] Make --enable_kyaml true by default.
+//  [ ] When 2 is not noticeably more buggy than 1, delete 1.
+//      I.e. delete k8sdeps/, transitively deleting all k8s.io/api* deps.
+//      This DepProvider should be left in place to retain these
+//      comments, but it will have only one choice.
+//  [ ] The way is now clear to reintegrate into kubectl.
+//      This should be done ASAP; the last step is cleanup.
+//  [ ] With only one impl of Kunstructure remaining, that interface
+//      and WNode can be deleted, along with this DepProvider.
+//      The other two interfaces could be dropped too.
+//
+// When the above is done, kustomize will use yaml.RNode and/or
+// KRM Config Functions directly and exclusively.
+// If you're reading this, plan not done.
+//
+type DepProvider struct {
+	resourceFactory *resource.Factory
+	merginator      resmap.Merginator
+	fieldValidator  ifc.Validator
+}
+
+func makeK8sdepBasedInstances() *DepProvider {
+	kf := kunstruct.NewKunstructuredFactoryImpl()
+	rf := resource.NewFactory(kf)
+	return &DepProvider{
+		resourceFactory: rf,
+		merginator:      merge.NewMerginator(rf),
+		fieldValidator:  validator.NewKustValidator(),
+	}
+}
+
+func makeKyamlBasedInstances() *DepProvider {
+	kf := &wrappy.WNodeFactory{}
+	rf := resource.NewFactory(kf)
+	return &DepProvider{
+		resourceFactory: rf,
+		merginator:      kmerge.NewMerginator(rf),
+		fieldValidator:  validate.NewFieldValidator(),
+	}
+}
+
+func NewDepProvider(useKyaml bool) *DepProvider {
+	if useKyaml {
+		return makeKyamlBasedInstances()
+	}
+	return makeK8sdepBasedInstances()
+}
+
+func (dp *DepProvider) GetResourceFactory() *resource.Factory {
+	return dp.resourceFactory
+}
+
+func (dp *DepProvider) GetMerginator() resmap.Merginator {
+	return dp.merginator
+}
+
+func (dp *DepProvider) GetFieldValidator() ifc.Validator {
+	return dp.fieldValidator
+}

api/krusty/issue2896_test.go

@@ -0,0 +1,106 @@
+// 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 writeIssueBase(th kusttest_test.Harness) {
+	th.WriteK("base", `
+nameSuffix: -test-api
+
+resources:
+ - deploy.yaml
+`)
+	th.WriteF("base/deploy.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example
+spec:
+  template:
+    spec:
+      containers:
+        - name: example
+          image: example:1.0
+          volumeMounts:
+            - name: conf
+              mountPath: /etc/config
+      volumes:
+        - name: conf
+          configMap:
+            name: conf
+`)
+}
+
+func TestIssue2896Base(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	writeIssueBase(th)
+	m := th.Run("base", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example-test-api
+spec:
+  template:
+    spec:
+      containers:
+      - image: example:1.0
+        name: example
+        volumeMounts:
+        - mountPath: /etc/config
+          name: conf
+      volumes:
+      - configMap:
+          name: conf
+        name: conf
+`)
+}
+
+func TestIssue2896Overlay(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	writeIssueBase(th)
+	th.WriteK("overlay", `
+resources:
+  - ../base
+
+patches:
+  - patch: |-
+      apiVersion: apps/v1
+      kind: Deployment
+      metadata:
+        name: example
+      spec:
+        template:
+          spec:
+            containers:
+             - name: example
+               image: example:2.0
+`)
+
+	m := th.Run("overlay", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example-test-api
+spec:
+  template:
+    spec:
+      containers:
+      - image: example:2.0
+        name: example
+        volumeMounts:
+        - mountPath: /etc/config
+          name: conf
+      volumes:
+      - configMap:
+          name: conf
+        name: conf
+`)
+}

api/krusty/kustomizationmetadata_test.go

@@ -0,0 +1,57 @@
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+func TestKustomizationMetadata(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("/app/resources.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: testing123
+spec:
+  replicas: 1
+  selector: null
+  template:
+    spec:
+      containers:
+      - name: event
+        image: testing123
+        imagePullPolicy: IfNotPresent
+      imagePullSecrets: []`)
+
+	th.WriteK("/app", `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+metadata:
+  annotations:
+    config.kubernetes.io/local-config: "true"
+  labels:
+    foo: bar
+  name: test_kustomization
+resources:
+- resources.yaml  
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: testing123
+spec:
+  replicas: 1
+  selector: null
+  template:
+    spec:
+      containers:
+      - image: testing123
+        imagePullPolicy: IfNotPresent
+        name: event
+      imagePullSecrets: []
+`)
+}

api/krusty/kustomizer.go

@@ -8,16 +8,13 @@ import (
 
 	"sigs.k8s.io/kustomize/api/builtins"
 	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/internal/k8sdeps/merge"
 	pLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
 	"sigs.k8s.io/kustomize/api/internal/target"
-	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
-	"sigs.k8s.io/kustomize/api/k8sdeps/validator"
 	"sigs.k8s.io/kustomize/api/konfig"
+	"sigs.k8s.io/kustomize/api/krusty/internal/provider"
 	fLdr "sigs.k8s.io/kustomize/api/loader"
 	"sigs.k8s.io/kustomize/api/provenance"
 	"sigs.k8s.io/kustomize/api/resmap"
-	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
 )
 
@@ -28,13 +25,18 @@ import (
 // number of overlays and bases), then make a Kustomizer
 // injected with the given fileystem, then call Run.
 type Kustomizer struct {
-	fSys    filesys.FileSystem
-	options *Options
+	fSys        filesys.FileSystem
+	options     *Options
+	depProvider *provider.DepProvider
 }
 
 // MakeKustomizer returns an instance of Kustomizer.
 func MakeKustomizer(fSys filesys.FileSystem, o *Options) *Kustomizer {
-	return &Kustomizer{fSys: fSys, options: o}
+	return &Kustomizer{
+		fSys:        fSys,
+		options:     o,
+		depProvider: provider.NewDepProvider(o.UseKyaml),
+	}
 }
 
 // Run performs a kustomization.
@@ -49,11 +51,9 @@ func MakeKustomizer(fSys filesys.FileSystem, o *Options) *Kustomizer {
 // on any number of internal paths (e.g. the filesystem may contain
 // multiple overlays, and Run can be called on each of them).
 func (b *Kustomizer) Run(path string) (resmap.ResMap, error) {
-	resourceFactory := resource.NewFactory(
-		kunstruct.NewKunstructuredFactoryImpl())
 	resmapFactory := resmap.NewFactory(
-		resourceFactory,
-		merge.NewMerginator(resourceFactory))
+		b.depProvider.GetResourceFactory(),
+		b.depProvider.GetMerginator())
 	lr := fLdr.RestrictionNone
 	if b.options.LoadRestrictions == types.LoadRestrictionsRootOnly {
 		lr = fLdr.RestrictionRootOnly
@@ -65,7 +65,7 @@ func (b *Kustomizer) Run(path string) (resmap.ResMap, error) {
 	defer ldr.Cleanup()
 	kt := target.NewKustTarget(
 		ldr,
-		validator.NewKustValidator(),
+		b.depProvider.GetFieldValidator(),
 		resmapFactory,
 		pLdr.NewLoader(b.options.PluginConfig, resmapFactory),
 	)

api/krusty/multiplepatch_test.go

@@ -146,12 +146,12 @@ spec:
       - gcePersistentDisk:
           pdName: nginx-persistent-storage
         name: nginx-persistent-storage
-      - configMap:
-          name: a-b-configmap-in-base-798k5k7g9f
-        name: configmap-in-base
       - configMap:
           name: a-configmap-in-overlay-dc6fm46dhm
         name: configmap-in-overlay
+      - configMap:
+          name: a-b-configmap-in-base-798k5k7g9f
+        name: configmap-in-base
 ---
 apiVersion: v1
 kind: Service
@@ -351,12 +351,12 @@ spec:
       - gcePersistentDisk:
           pdName: nginx-persistent-storage
         name: nginx-persistent-storage
-      - configMap:
-          name: staging-team-foo-configmap-in-base-798k5k7g9f
-        name: configmap-in-base
       - 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

api/krusty/nameprefixsuffixpatch_test.go

@@ -104,10 +104,10 @@ spec:
         - valueFrom:
             configMapKeyRef:
               key: MYSQL_DATABASE
-              name: mysql
+              name: mysql-9792mdchtg
         envFrom:
         - configMapRef:
-            name: mysql
+            name: mysql-9792mdchtg
         name: handler
 `)
 }

api/krusty/namespaces_test.go

@@ -159,7 +159,7 @@ subjects:
   name: default
   namespace: irrelevant
 ---
-apiVersion: admissionregistration.k8s.io/v1beta1
+apiVersion: admissionregistration.k8s.io/v1
 kind: ValidatingWebhookConfiguration
 metadata:
   name: example
@@ -180,15 +180,17 @@ webhooks:
         name: svc3
         namespace: random
 ---
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   name: crds.my.org
 ---
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
   name: cr1
 ---
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
   name: crb1
@@ -197,6 +199,7 @@ subjects:
   name: default
   namespace: irrelevant
 ---
+apiVersion: v1
 kind: PersistentVolume
 metadata:
   name: pv1
@@ -257,7 +260,7 @@ subjects:
   name: default
   namespace: newnamespace
 ---
-apiVersion: admissionregistration.k8s.io/v1beta1
+apiVersion: admissionregistration.k8s.io/v1
 kind: ValidatingWebhookConfiguration
 metadata:
   name: p1-example-s1
@@ -278,15 +281,17 @@ webhooks:
       namespace: random
   name: example3
 ---
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   name: crds.my.org
 ---
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
   name: p1-cr1-s1
 ---
+apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
   name: p1-crb1-s1
@@ -295,6 +300,7 @@ subjects:
   name: default
   namespace: newnamespace
 ---
+apiVersion: v1
 kind: PersistentVolume
 metadata:
   name: p1-pv1-s1

api/krusty/nameupdateinroleref_test.go

@@ -0,0 +1,287 @@
+package krusty_test
+
+import (
+	"testing"
+
+	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
+)
+
+// https://github.com/kubernetes-sigs/kustomize/issues/2640
+func TestNameUpdateInRoleRef(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("/app/rbac.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: my-role
+rules:
+- apiGroups:
+  - '*'
+  resources:
+  - '*'
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: my-role
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: my-role
+subjects:
+- kind: ServiceAccount
+  name: default
+  namespace: foo
+--- 
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: my-role
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - secrets
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: my-role
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  version: v1
+  kind: Role
+  name: my-role
+subjects:
+- kind: ServiceAccount
+  name: default
+`)
+
+	th.WriteK("/app", `
+namespace: foo
+resources:
+- rbac.yaml
+
+patches:
+- patch: |-
+    - op: add
+      path: /metadata/name
+      value: prefix_my-role
+  target:
+    group: rbac.authorization.k8s.io
+    version: v1
+    kind: ClusterRole
+    name: my-role
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: prefix_my-role
+rules:
+- apiGroups:
+  - '*'
+  resources:
+  - '*'
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: my-role
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: prefix_my-role
+subjects:
+- kind: ServiceAccount
+  name: default
+  namespace: foo
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: my-role
+  namespace: foo
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - secrets
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: my-role
+  namespace: foo
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: my-role
+  version: v1
+subjects:
+- kind: ServiceAccount
+  name: default
+  namespace: foo
+`)
+}
+
+// https://github.com/kubernetes-sigs/kustomize/issues/3073
+func TestNameUpdateInRoleRef2(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("/app/workloads.yaml", `
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: myapp
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: myapp
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - nodes/metrics
+  verbs:
+  - get
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: myapp
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: myapp
+subjects:
+- kind: ServiceAccount
+  name: myapp
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: myapp
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - services
+  verbs:
+  - get
+
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: myapp
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: myapp
+subjects:
+- kind: ServiceAccount
+  name: myapp
+`)
+
+	th.WriteF("/app/suffixTransformer.yaml", `
+apiVersion: builtin
+kind: PrefixSuffixTransformer
+metadata:
+  name: notImportantHere
+suffix: -suffix
+fieldSpecs:
+- path: metadata/name
+  kind: ClusterRole
+  name: myapp
+- path: metadata/name
+  kind: ClusterRoleBinding
+  name: myapp
+`)
+
+	th.WriteK("/app", `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+- workloads.yaml
+transformers:
+- suffixTransformer.yaml
+namespace: test
+
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: myapp
+  namespace: test
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: myapp-suffix
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - nodes/metrics
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: myapp-suffix
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: myapp-suffix
+subjects:
+- kind: ServiceAccount
+  name: myapp
+  namespace: test
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: myapp
+  namespace: test
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - services
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: myapp
+  namespace: test
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: myapp
+subjects:
+- kind: ServiceAccount
+  name: myapp
+  namespace: test
+`)
+}

api/krusty/nullvalues_test.go

@@ -9,7 +9,7 @@ import (
 	kusttest_test "sigs.k8s.io/kustomize/api/testutils/kusttest"
 )
 
-func TestNullValues(t *testing.T) {
+func TestNullValues1(t *testing.T) {
 	th := kusttest_test.MakeHarness(t)
 	th.WriteF("/app/deployment.yaml", `
 apiVersion: apps/v1
@@ -62,3 +62,36 @@ spec:
         name: example
 `)
 }
+
+func TestNullValues2(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteF("deploy.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test
+spec:
+  template:
+    spec:
+      containers:
+        - name: test
+      volumes: null
+`)
+	th.WriteK(".", `
+resources:
+- deploy.yaml
+`)
+	m := th.Run(".", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test
+spec:
+  template:
+    spec:
+      containers:
+      - name: test
+      volumes: null
+`)
+}

api/krusty/options.go

@@ -32,14 +32,20 @@ type Options struct {
 
 	// Options related to kustomize plugins.
 	PluginConfig *types.PluginConfig
+
+	// When true, use kyaml/ packages to manipulate KRM yaml.
+	// When false, use k8sdeps/ instead (uses k8s.io/api* packages).
+	UseKyaml bool
 }
 
 // MakeDefaultOptions returns a default instance of Options.
 func MakeDefaultOptions() *Options {
 	return &Options{
-		DoLegacyResourceSort: true,
+		DoLegacyResourceSort: false,
+		AddManagedbyLabel:    false,
 		LoadRestrictions:     types.LoadRestrictionsRootOnly,
 		DoPrune:              false,
 		PluginConfig:         konfig.DisabledPluginConfig(),
+		UseKyaml:             false,
 	}
 }

api/krusty/rolebindingacrossnamespace_test.go

@@ -213,3 +213,132 @@ roleRef:
   name: my-role-ns2
 `)
 }
+
+// The ServiceAccount in subjects in role binding can be across namespace
+// but the roleRef is not. This test is used to cover such case.
+func TestRoleBindingWhenSubjectsAcrossNamespace(t *testing.T) {
+	th := kusttest_test.MakeEnhancedHarness(t)
+	defer th.Reset()
+	th.WriteK("/app", `
+resources:
+- ./ns1
+- ./ns2
+`)
+	th.WriteK("/app/ns1", `
+namespace: namespace-1
+resources:
+- role-ns1.yaml
+- rolebinding-ns1.yaml
+`)
+	th.WriteF("/app/ns1/role-ns1.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: testRole
+rules:
+  - apiGroups: [""]
+    resources: ["pods"]
+    verbs: ["get"]
+`)
+	th.WriteF("/app/ns1/rolebinding-ns1.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: testRoleBinding
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: testRole
+subjects:
+  - kind: ServiceAccount
+    name: testAccount
+    namespace: namespace-2
+`)
+	th.WriteK("/app/ns2", `
+namespace: namespace-2
+resources:
+- role-ns2.yaml
+- rolebinding-ns2.yaml
+`)
+	th.WriteF("/app/ns2/role-ns2.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: testRole
+rules:
+  - apiGroups: [""]
+    resources: ["pods"]
+    verbs: ["get"]
+`)
+	th.WriteF("/app/ns2/rolebinding-ns2.yaml", `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: testRoleBinding
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: testRole
+subjects:
+  - kind: ServiceAccount
+    name: testAccount
+    namespace: namespace-1
+`)
+
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: testRole
+  namespace: namespace-1
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: testRoleBinding
+  namespace: namespace-1
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: testRole
+subjects:
+- kind: ServiceAccount
+  name: testAccount
+  namespace: namespace-2
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: testRole
+  namespace: namespace-2
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  verbs:
+  - get
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: testRoleBinding
+  namespace: namespace-2
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: testRole
+subjects:
+- kind: ServiceAccount
+  name: testAccount
+  namespace: namespace-1
+`)
+}

api/krusty/transformersimage_test.go

@@ -215,25 +215,25 @@ spec2:
   template:
     spec:
       containers:
-      - image: nginx:v1
+      - image: nginx:v2
         name: nginx3
-      - image: my-nginx:latest
+      - image: my-nginx:previous
         name: nginx4
 spec3:
   template:
     spec:
       initContainers:
-      - image: postgres:alpine-9
+      - image: my-postgres:v3
         name: postgresdb
-      - image: docker:17-git
+      - image: my-docker@sha256:25a0d4b4
         name: init-docker
-      - image: myprivaterepohostname:1234/my/image:latest
+      - image: myprivaterepohostname:1234/my/image:v1.0.1
         name: myImage
-      - image: myprivaterepohostname:1234/my/image
+      - image: myprivaterepohostname:1234/my/image:v1.0.1
         name: myImage2
       - image: my-app-image:v1
         name: my-app
-      - image: gcr.io:8080/my-project/my-cool-app:latest
+      - image: my-cool-app:latest
         name: my-cool-app
 `)
 }

api/krusty/variableref_test.go

@@ -1969,3 +1969,70 @@ spec:
     server: kustomized-nfs-server-service.default.srv.cluster.local
 `)
 }
+
+func TestDeploymentAnnotations(t *testing.T) {
+	th := kusttest_test.MakeHarness(t)
+	th.WriteK("/app", `
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+
+configMapGenerator:
+  - name: testConfigMap
+    envs:
+      - test.properties
+
+vars:
+  - name: FOO
+    objref:
+      kind: ConfigMap
+      name: testConfigMap
+      apiVersion: v1
+    fieldref:
+      fieldpath: data.foo
+
+commonAnnotations:
+  foo: $(FOO)
+
+resources:
+  - deployment.yaml
+`)
+
+	th.WriteF("/app/deployment.yaml", `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test
+spec:
+  template:
+    spec:
+      containers:
+        - name: test
+`)
+	th.WriteF("/app/test.properties", `foo=bar`)
+	m := th.Run("/app", th.MakeDefaultOptions())
+	th.AssertActualEqualsExpected(m, `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  annotations:
+    foo: bar
+  name: test
+spec:
+  template:
+    metadata:
+      annotations:
+        foo: bar
+    spec:
+      containers:
+      - name: test
+---
+apiVersion: v1
+data:
+  foo: bar
+kind: ConfigMap
+metadata:
+  annotations:
+    foo: bar
+  name: testConfigMap-798k5k7g9f
+`)
+}

api/loader/getter.go

@@ -20,6 +20,9 @@ type remoteTargetSpec struct {
 
 	// Dir is where the resource is saved
 	Dir filesys.ConfirmedDir
+
+	// TempDir is the directory created to hold all resources, including Dir
+	TempDir filesys.ConfirmedDir
 }
 
 // Getter is a function that can gets resource
@@ -31,7 +34,7 @@ func newLoaderAtGetter(raw string, fSys filesys.FileSystem, referrer *fileLoader
 	}
 
 	cleaner := func() error {
-		return fSys.RemoveAll(rs.Dir.String())
+		return fSys.RemoveAll(rs.TempDir.String())
 	}
 
 	if err := getter(rs); err != nil {
@@ -55,12 +58,12 @@ func newLoaderAtGetter(raw string, fSys filesys.FileSystem, referrer *fileLoader
 func getRemoteTarget(rs *remoteTargetSpec) error {
 	var err error
 
-	rs.Dir, err = filesys.NewTmpConfirmedDir()
+	rs.TempDir, err = filesys.NewTmpConfirmedDir()
 	if err != nil {
 		return err
 	}
 
-	rs.Dir = filesys.ConfirmedDir(rs.Dir.Join("repo"))
+	rs.Dir = filesys.ConfirmedDir(rs.TempDir.Join("repo"))
 
 	// Get the pwd
 	pwd, err := os.Getwd()

api/resid/gvk.go

@@ -5,6 +5,9 @@ package resid
 
 import (
 	"strings"
+
+	"sigs.k8s.io/kustomize/kyaml/openapi"
+	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
 // Gvk identifies a Kubernetes API type.
@@ -77,6 +80,22 @@ func (x Gvk) String() string {
 	return strings.Join([]string{g, v, k}, fieldSep)
 }
 
+// StringWoEmptyField returns a string representation of the GVK. Non-exist
+// fields will be omitted.
+func (x Gvk) StringWoEmptyField() string {
+	var s []string
+	if x.Group != "" {
+		s = append(s, x.Group)
+	}
+	if x.Version != "" {
+		s = append(s, x.Version)
+	}
+	if x.Kind != "" {
+		s = append(s, x.Kind)
+	}
+	return strings.Join(s, fieldSep)
+}
+
 // Equals returns true if the Gvk's have equal fields.
 func (x Gvk) Equals(o Gvk) bool {
 	return x.Group == o.Group && x.Version == o.Version && x.Kind == o.Kind
@@ -99,6 +118,7 @@ var orderFirst = []string{
 	"ClusterRoleBinding",
 	"ConfigMap",
 	"Secret",
+	"Endpoints",
 	"Service",
 	"LimitRange",
 	"PriorityClass",
@@ -171,39 +191,23 @@ func (x Gvk) IsSelected(selector *Gvk) bool {
 	return true
 }
 
-var notNamespaceableKinds = []string{
-	"APIService",
-	"CSIDriver",
-	"CSINode",
-	"CertificateSigningRequest",
-	"Cluster",
-	"ClusterRole",
-	"ClusterRoleBinding",
-	"ComponentStatus",
-	"CustomResourceDefinition",
-	"MutatingWebhookConfiguration",
-	"Namespace",
-	"Node",
-	"PersistentVolume",
-	"PodSecurityPolicy",
-	"PriorityClass",
-	"RuntimeClass",
-	"SelfSubjectAccessReview",
-	"SelfSubjectRulesReview",
-	"StorageClass",
-	"SubjectAccessReview",
-	"TokenReview",
-	"ValidatingWebhookConfiguration",
-	"VolumeAttachment",
+// toKyamlTypeMeta returns a yaml.TypeMeta from x's information.
+func (x Gvk) toKyamlTypeMeta() yaml.TypeMeta {
+	var apiVersion strings.Builder
+	if x.Group != "" {
+		apiVersion.WriteString(x.Group)
+		apiVersion.WriteString("/")
+	}
+	apiVersion.WriteString(x.Version)
+	return yaml.TypeMeta{
+		APIVersion: apiVersion.String(),
+		Kind:       x.Kind,
+	}
 }
 
 // IsNamespaceableKind returns true if x is a namespaceable Gvk
 // Implements https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#not-all-objects-are-in-a-namespace
 func (x Gvk) IsNamespaceableKind() bool {
-	for _, k := range notNamespaceableKinds {
-		if k == x.Kind {
-			return false
-		}
-	}
-	return true
+	isNamespaceScoped, found := openapi.IsNamespaceScoped(x.toKyamlTypeMeta())
+	return !found || isNamespaceScoped
 }

api/resid/gvk_test.go

@@ -18,6 +18,8 @@ package resid
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 var equalsTests = []struct {
@@ -78,6 +80,8 @@ var lessThanTests = []struct {
 		Gvk{Group: "a", Version: "b", Kind: "ValidatingWebhookConfiguration"}},
 	{Gvk{Group: "a", Version: "b", Kind: "Service"},
 		Gvk{Group: "a", Version: "b", Kind: "APIService"}},
+	{Gvk{Group: "a", Version: "b", Kind: "Endpoints"},
+		Gvk{Group: "a", Version: "b", Kind: "Service"}},
 }
 
 func TestIsLessThan1(t *testing.T) {
@@ -94,15 +98,16 @@ func TestIsLessThan1(t *testing.T) {
 var stringTests = []struct {
 	x Gvk
 	s string
+	r string
 }{
-	{Gvk{}, "~G_~V_~K"},
-	{Gvk{Kind: "k"}, "~G_~V_k"},
-	{Gvk{Version: "v"}, "~G_v_~K"},
-	{Gvk{Version: "v", Kind: "k"}, "~G_v_k"},
-	{Gvk{Group: "g"}, "g_~V_~K"},
-	{Gvk{Group: "g", Kind: "k"}, "g_~V_k"},
-	{Gvk{Group: "g", Version: "v"}, "g_v_~K"},
-	{Gvk{Group: "g", Version: "v", Kind: "k"}, "g_v_k"},
+	{Gvk{}, "~G_~V_~K", ""},
+	{Gvk{Kind: "k"}, "~G_~V_k", "k"},
+	{Gvk{Version: "v"}, "~G_v_~K", "v"},
+	{Gvk{Version: "v", Kind: "k"}, "~G_v_k", "v_k"},
+	{Gvk{Group: "g"}, "g_~V_~K", "g"},
+	{Gvk{Group: "g", Kind: "k"}, "g_~V_k", "g_k"},
+	{Gvk{Group: "g", Version: "v"}, "g_v_~K", "g_v"},
+	{Gvk{Group: "g", Version: "v", Kind: "k"}, "g_v_k", "g_v_k"},
 }
 
 func TestString(t *testing.T) {
@@ -113,6 +118,14 @@ func TestString(t *testing.T) {
 	}
 }
 
+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)
+		}
+	}
+}
+
 func TestParseGroupVersion(t *testing.T) {
 	tests := []struct {
 		input string
@@ -244,3 +257,40 @@ func TestSelectByGVK(t *testing.T) {
 		}
 	}
 }
+
+func TestIsNamespaceableKind(t *testing.T) {
+	testCases := []struct {
+		name     string
+		gvk      Gvk
+		expected bool
+	}{
+		{
+			"namespaceable resource",
+			Gvk{Group: "apps", Version: "v1", Kind: "Deployment"},
+			true,
+		},
+		{
+			"clusterscoped resource",
+			Gvk{Group: "", Version: "v1", Kind: "Namespace"},
+			false,
+		},
+		{
+			"unknown resource (should default to namespaceable)",
+			Gvk{Group: "example1.com", Version: "v1", Kind: "Bar"},
+			true,
+		},
+		{
+			"unknown resource (should default to namespaceable)",
+			Gvk{Group: "apps", Version: "v1", Kind: "ClusterRoleBinding"},
+			true,
+		},
+	}
+
+	for i := range testCases {
+		test := testCases[i]
+		t.Run(test.name, func(t *testing.T) {
+			isNamespaceable := test.gvk.IsNamespaceableKind()
+			assert.Equal(t, test.expected, isNamespaceable)
+		})
+	}
+}

api/resid/resid_test.go

@@ -265,7 +265,7 @@ func TestResIdEquals(t *testing.T) {
 				Name: "nm",
 			},
 			gVknResult: false,
-			nsEquals:   false,
+			nsEquals:   true,
 			equals:     false,
 		},
 		{
@@ -376,7 +376,7 @@ func TestEffectiveNamespace(t *testing.T) {
 	}{
 		{
 			id: ResId{
-				Gvk:  Gvk{Group: "g", Version: "v", Kind: "Node"},
+				Gvk:  Gvk{Group: "", Version: "v1", Kind: "Node"},
 				Name: "nm",
 			},
 			expected: TotallyNotANamespace,
@@ -384,7 +384,7 @@ func TestEffectiveNamespace(t *testing.T) {
 		{
 			id: ResId{
 				Namespace: "foo",
-				Gvk:       Gvk{Group: "g", Version: "v", Kind: "Node"},
+				Gvk:       Gvk{Group: "", Version: "v1", Kind: "Node"},
 				Name:      "nm",
 			},
 			expected: TotallyNotANamespace,

api/resmap/factory.go

@@ -11,10 +11,19 @@ import (
 	"sigs.k8s.io/kustomize/api/types"
 )
 
+// Merginator merges resources.
+type Merginator interface {
+	// Merge creates a new ResMap by merging incoming resources.
+	// Error if conflict found.
+	Merge([]*resource.Resource) (ResMap, error)
+}
+
 // Factory makes instances of ResMap.
 type Factory struct {
+	// Makes resources.
 	resF *resource.Factory
-	pm   Merginator
+	// Makes ResMaps via merging.
+	pm Merginator
 }
 
 // NewFactory returns a new resmap.Factory.

api/resmap/merginator.go

@@ -1,13 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package resmap
-
-import "sigs.k8s.io/kustomize/api/resource"
-
-// Merginator merges resources.
-type Merginator interface {
-	// Merge creates a new ResMap by merging incoming resources.
-	// Error if conflict found.
-	Merge([]*resource.Resource) (ResMap, error)
-}

api/resmap/resmap.go

@@ -6,16 +6,10 @@
 package resmap
 
 import (
-	"bytes"
-	"fmt"
-	"regexp"
-
-	"github.com/pkg/errors"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/resid"
 	"sigs.k8s.io/kustomize/api/resource"
 	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/yaml"
 )
 
 // A Transformer modifies an instance of ResMap.
@@ -242,569 +236,3 @@ type ResMap interface {
 	// are selected by a Selector
 	Select(types.Selector) ([]*resource.Resource, error)
 }
-
-// resWrangler holds the content manipulated by kustomize.
-type resWrangler struct {
-	// Resource list maintained in load (append) order.
-	// This is important for transformers, which must
-	// be performed in a specific order, and for users
-	// who for whatever reasons wish the order they
-	// specify in kustomizations to be maintained and
-	// available as an option for final YAML rendering.
-	rList []*resource.Resource
-}
-
-func newOne() *resWrangler {
-	result := &resWrangler{}
-	result.Clear()
-	return result
-}
-
-// Clear implements ResMap.
-func (m *resWrangler) Clear() {
-	m.rList = nil
-}
-
-// Size implements ResMap.
-func (m *resWrangler) Size() int {
-	return len(m.rList)
-}
-
-func (m *resWrangler) indexOfResource(other *resource.Resource) int {
-	for i, r := range m.rList {
-		if r == other {
-			return i
-		}
-	}
-	return -1
-}
-
-// Resources implements ResMap.
-func (m *resWrangler) Resources() []*resource.Resource {
-	tmp := make([]*resource.Resource, len(m.rList))
-	copy(tmp, m.rList)
-	return tmp
-}
-
-// Append implements ResMap.
-func (m *resWrangler) Append(res *resource.Resource) error {
-	id := res.CurId()
-	if r := m.GetMatchingResourcesByCurrentId(id.Equals); len(r) > 0 {
-		return fmt.Errorf(
-			"may not add resource with an already registered id: %s", id)
-	}
-	m.rList = append(m.rList, res)
-	return nil
-}
-
-// Remove implements ResMap.
-func (m *resWrangler) Remove(adios resid.ResId) error {
-	tmp := newOne()
-	for _, r := range m.rList {
-		if r.CurId() != adios {
-			tmp.Append(r)
-		}
-	}
-	if tmp.Size() != m.Size()-1 {
-		return fmt.Errorf("id %s not found in removal", adios)
-	}
-	m.rList = tmp.rList
-	return nil
-}
-
-// Replace implements ResMap.
-func (m *resWrangler) Replace(res *resource.Resource) (int, error) {
-	id := res.CurId()
-	i, err := m.GetIndexOfCurrentId(id)
-	if err != nil {
-		return -1, errors.Wrap(err, "in Replace")
-	}
-	if i < 0 {
-		return -1, fmt.Errorf("cannot find resource with id %s to replace", id)
-	}
-	m.rList[i] = res
-	return i, nil
-}
-
-// AllIds implements ResMap.
-func (m *resWrangler) AllIds() (ids []resid.ResId) {
-	ids = make([]resid.ResId, m.Size())
-	for i, r := range m.rList {
-		ids[i] = r.CurId()
-	}
-	return
-}
-
-// Debug implements ResMap.
-func (m *resWrangler) Debug(title string) {
-	fmt.Println("--------------------------- " + title)
-	firstObj := true
-	for i, r := range m.rList {
-		if firstObj {
-			firstObj = false
-		} else {
-			fmt.Println("---")
-		}
-		fmt.Printf("# %d  %s\n", i, r.OrgId())
-		blob, err := yaml.Marshal(r.Map())
-		if err != nil {
-			panic(err)
-		}
-		fmt.Println(string(blob))
-	}
-}
-
-type IdMatcher func(resid.ResId) bool
-
-// GetByIndex implements ResMap.
-func (m *resWrangler) GetByIndex(i int) *resource.Resource {
-	if i < 0 || i >= m.Size() {
-		return nil
-	}
-	return m.rList[i]
-}
-
-// GetIndexOfCurrentId implements ResMap.
-func (m *resWrangler) GetIndexOfCurrentId(id resid.ResId) (int, error) {
-	count := 0
-	result := -1
-	for i, r := range m.rList {
-		if id.Equals(r.CurId()) {
-			count++
-			result = i
-		}
-	}
-	if count > 1 {
-		return -1, fmt.Errorf("id matched %d resources", count)
-	}
-	return result, nil
-}
-
-type IdFromResource func(r *resource.Resource) resid.ResId
-
-func GetOriginalId(r *resource.Resource) resid.ResId { return r.OrgId() }
-func GetCurrentId(r *resource.Resource) resid.ResId  { return r.CurId() }
-
-// GetMatchingResourcesByCurrentId implements ResMap.
-func (m *resWrangler) GetMatchingResourcesByCurrentId(
-	matches IdMatcher) []*resource.Resource {
-	return m.filteredById(matches, GetCurrentId)
-}
-
-// GetMatchingResourcesByOriginalId implements ResMap.
-func (m *resWrangler) GetMatchingResourcesByOriginalId(
-	matches IdMatcher) []*resource.Resource {
-	return m.filteredById(matches, GetOriginalId)
-}
-
-func (m *resWrangler) filteredById(
-	matches IdMatcher, idGetter IdFromResource) []*resource.Resource {
-	var result []*resource.Resource
-	for _, r := range m.rList {
-		if matches(idGetter(r)) {
-			result = append(result, r)
-		}
-	}
-	return result
-}
-
-// GetByCurrentId implements ResMap.
-func (m *resWrangler) GetByCurrentId(
-	id resid.ResId) (*resource.Resource, error) {
-	return demandOneMatch(m.GetMatchingResourcesByCurrentId, id, "Current")
-}
-
-// GetByOriginalId implements ResMap.
-func (m *resWrangler) GetByOriginalId(
-	id resid.ResId) (*resource.Resource, error) {
-	return demandOneMatch(m.GetMatchingResourcesByOriginalId, id, "Original")
-}
-
-// GetById implements ResMap.
-func (m *resWrangler) GetById(
-	id resid.ResId) (*resource.Resource, error) {
-	match, err1 := m.GetByOriginalId(id)
-	if err1 == nil {
-		return match, nil
-	}
-	match, err2 := m.GetByCurrentId(id)
-	if err2 == nil {
-		return match, nil
-	}
-	return nil, fmt.Errorf(
-		"%s; %s; failed to find unique target for patch %s",
-		err1.Error(), err2.Error(), id.GvknString())
-}
-
-type resFinder func(IdMatcher) []*resource.Resource
-
-func demandOneMatch(
-	f resFinder, id resid.ResId, s string) (*resource.Resource, error) {
-	r := f(id.Equals)
-	if len(r) == 1 {
-		return r[0], nil
-	}
-	if len(r) > 1 {
-		return nil, fmt.Errorf("multiple matches for %sId %s", s, id)
-	}
-	return nil, fmt.Errorf("no matches for %sId %s", s, id)
-}
-
-// GroupedByCurrentNamespace implements ResMap.GroupByCurrentNamespace
-func (m *resWrangler) GroupedByCurrentNamespace() map[string][]*resource.Resource {
-	items := m.groupedByCurrentNamespace()
-	delete(items, resid.TotallyNotANamespace)
-	return items
-}
-
-// NonNamespaceable implements ResMap.NonNamespaceable
-func (m *resWrangler) NonNamespaceable() []*resource.Resource {
-	return m.groupedByCurrentNamespace()[resid.TotallyNotANamespace]
-}
-
-func (m *resWrangler) groupedByCurrentNamespace() map[string][]*resource.Resource {
-	byNamespace := make(map[string][]*resource.Resource)
-	for _, res := range m.rList {
-		namespace := res.CurId().EffectiveNamespace()
-		if _, found := byNamespace[namespace]; !found {
-			byNamespace[namespace] = []*resource.Resource{}
-		}
-		byNamespace[namespace] = append(byNamespace[namespace], res)
-	}
-	return byNamespace
-}
-
-// GroupedByNamespace implements ResMap.GroupByOrginalNamespace
-func (m *resWrangler) GroupedByOriginalNamespace() map[string][]*resource.Resource {
-	items := m.groupedByOriginalNamespace()
-	delete(items, resid.TotallyNotANamespace)
-	return items
-}
-
-func (m *resWrangler) groupedByOriginalNamespace() map[string][]*resource.Resource {
-	byNamespace := make(map[string][]*resource.Resource)
-	for _, res := range m.rList {
-		namespace := res.OrgId().EffectiveNamespace()
-		if _, found := byNamespace[namespace]; !found {
-			byNamespace[namespace] = []*resource.Resource{}
-		}
-		byNamespace[namespace] = append(byNamespace[namespace], res)
-	}
-	return byNamespace
-}
-
-// AsYaml implements ResMap.
-func (m *resWrangler) AsYaml() ([]byte, error) {
-	firstObj := true
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	for _, res := range m.Resources() {
-		out, err := yaml.Marshal(res.Map())
-		if err != nil {
-			return nil, err
-		}
-		if firstObj {
-			firstObj = false
-		} else {
-			if _, err = buf.WriteString("---\n"); err != nil {
-				return nil, err
-			}
-		}
-		if _, err = buf.Write(out); err != nil {
-			return nil, err
-		}
-	}
-	return buf.Bytes(), nil
-}
-
-// ErrorIfNotEqualSets implements ResMap.
-func (m *resWrangler) ErrorIfNotEqualSets(other ResMap) error {
-	m2, ok := other.(*resWrangler)
-	if !ok {
-		panic("bad cast")
-	}
-	if m.Size() != m2.Size() {
-		return fmt.Errorf(
-			"lists have different number of entries: %#v doesn't equal %#v",
-			m.rList, m2.rList)
-	}
-	seen := make(map[int]bool)
-	for _, r1 := range m.rList {
-		id := r1.CurId()
-		others := m2.GetMatchingResourcesByCurrentId(id.Equals)
-		if len(others) == 0 {
-			return fmt.Errorf(
-				"id in self missing from other; id: %s", id)
-		}
-		if len(others) > 1 {
-			return fmt.Errorf(
-				"id in self matches %d in other; id: %s", len(others), id)
-		}
-		r2 := others[0]
-		if !r1.KunstructEqual(r2) {
-			return fmt.Errorf(
-				"kunstruct not equal: \n -- %s,\n -- %s\n\n--\n%#v\n------\n%#v\n",
-				r1, r2, r1, r2)
-		}
-		seen[m2.indexOfResource(r2)] = true
-	}
-	if len(seen) != m.Size() {
-		return fmt.Errorf("counting problem %d != %d", len(seen), m.Size())
-	}
-	return nil
-}
-
-// ErrorIfNotEqualList implements ResMap.
-func (m *resWrangler) ErrorIfNotEqualLists(other ResMap) error {
-	m2, ok := other.(*resWrangler)
-	if !ok {
-		panic("bad cast")
-	}
-	if m.Size() != m2.Size() {
-		return fmt.Errorf(
-			"lists have different number of entries: %#v doesn't equal %#v",
-			m.rList, m2.rList)
-	}
-	for i, r1 := range m.rList {
-		r2 := m2.rList[i]
-		if !r1.Equals(r2) {
-			return fmt.Errorf(
-				"Item i=%d differs:\n  n1 = %s\n  n2 = %s\n  o1 = %s\n  o2 = %s\n",
-				i, r1.OrgId(), r2.OrgId(), r1, r2)
-		}
-	}
-	return nil
-}
-
-type resCopier func(r *resource.Resource) *resource.Resource
-
-// ShallowCopy implements ResMap.
-func (m *resWrangler) ShallowCopy() ResMap {
-	return m.makeCopy(
-		func(r *resource.Resource) *resource.Resource {
-			return r
-		})
-}
-
-// DeepCopy implements ResMap.
-func (m *resWrangler) DeepCopy() ResMap {
-	return m.makeCopy(
-		func(r *resource.Resource) *resource.Resource {
-			return r.DeepCopy()
-		})
-}
-
-// makeCopy copies the ResMap.
-func (m *resWrangler) makeCopy(copier resCopier) ResMap {
-	result := &resWrangler{}
-	result.rList = make([]*resource.Resource, m.Size())
-	for i, r := range m.rList {
-		result.rList[i] = copier(r)
-	}
-	return result
-}
-
-// SubsetThatCouldBeReferencedByResource implements ResMap.
-func (m *resWrangler) SubsetThatCouldBeReferencedByResource(
-	inputRes *resource.Resource) ResMap {
-	result := newOne()
-	inputId := inputRes.CurId()
-	isInputIdNamespaceable := inputId.IsNamespaceableKind()
-	rctxm := inputRes.PrefixesSuffixesEquals
-	subjectNamespaces := getNamespacesForRoleBinding(inputRes)
-	for _, r := range m.Resources() {
-		// Need to match more accuratly both at the time of selection and transformation.
-		// OutmostPrefixSuffixEquals is not accurate enough since it is only using
-		// the outer most suffix and the last prefix. Use PrefixedSuffixesEquals instead.
-		resId := r.CurId()
-		if (!isInputIdNamespaceable || !resId.IsNamespaceableKind() || resId.IsNsEquals(inputId) ||
-			isRoleBindingNamespace(&subjectNamespaces, r.GetNamespace())) && r.InSameKustomizeCtx(rctxm) {
-			result.append(r)
-		}
-	}
-	return result
-}
-
-// isRoleBindingNamespace returns true is the namespace `ns` is in role binding
-// namespaces `m`
-func isRoleBindingNamespace(m *map[string]bool, ns string) bool {
-	return (*m)[ns]
-}
-
-// getNamespacesForRoleBinding returns referenced ServiceAccount namespaces if the inputRes is
-// a RoleBinding
-func getNamespacesForRoleBinding(inputRes *resource.Resource) map[string]bool {
-	res := make(map[string]bool)
-	if inputRes.GetKind() != "RoleBinding" {
-		return res
-	}
-	subjects, err := inputRes.GetSlice("subjects")
-	if err != nil || subjects == nil {
-		return res
-	}
-
-	for _, s := range subjects {
-		subject := s.(map[string]interface{})
-		if subject["namespace"] == nil || subject["kind"] == nil ||
-			subject["kind"].(string) != "ServiceAccount" {
-			continue
-		}
-		res[subject["namespace"].(string)] = true
-	}
-
-	return res
-}
-
-func (m *resWrangler) append(res *resource.Resource) {
-	m.rList = append(m.rList, res)
-}
-
-// AppendAll implements ResMap.
-func (m *resWrangler) AppendAll(other ResMap) error {
-	if other == nil {
-		return nil
-	}
-	for _, res := range other.Resources() {
-		if err := m.Append(res); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// AbsorbAll implements ResMap.
-func (m *resWrangler) AbsorbAll(other ResMap) error {
-	if other == nil {
-		return nil
-	}
-	for _, r := range other.Resources() {
-		err := m.appendReplaceOrMerge(r)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (m *resWrangler) appendReplaceOrMerge(
-	res *resource.Resource) error {
-	id := res.CurId()
-	matches := m.GetMatchingResourcesByOriginalId(id.Equals)
-	if len(matches) == 0 {
-		matches = m.GetMatchingResourcesByCurrentId(id.Equals)
-	}
-	switch len(matches) {
-	case 0:
-		switch res.Behavior() {
-		case types.BehaviorMerge, types.BehaviorReplace:
-			return fmt.Errorf(
-				"id %#v does not exist; cannot merge or replace", id)
-		default:
-			// presumably types.BehaviorCreate
-			err := m.Append(res)
-			if err != nil {
-				return err
-			}
-		}
-	case 1:
-		old := matches[0]
-		if old == nil {
-			return fmt.Errorf("id lookup failure")
-		}
-		index := m.indexOfResource(old)
-		if index < 0 {
-			return fmt.Errorf("indexing problem")
-		}
-		switch res.Behavior() {
-		case types.BehaviorReplace:
-			res.Replace(old)
-		case types.BehaviorMerge:
-			res.Merge(old)
-		default:
-			return fmt.Errorf(
-				"id %#v exists; behavior must be merge or replace", id)
-		}
-		i, err := m.Replace(res)
-		if err != nil {
-			return err
-		}
-		if i != index {
-			return fmt.Errorf("unexpected index in replacement")
-		}
-	default:
-		return fmt.Errorf(
-			"found multiple objects %v that could accept merge of %v",
-			matches, id)
-	}
-	return nil
-}
-
-func anchorRegex(pattern string) string {
-	if pattern == "" {
-		return pattern
-	}
-	return "^" + pattern + "$"
-}
-
-// Select returns a list of resources that
-// are selected by a Selector
-func (m *resWrangler) Select(s types.Selector) ([]*resource.Resource, error) {
-	ns := regexp.MustCompile(anchorRegex(s.Namespace))
-	nm := regexp.MustCompile(anchorRegex(s.Name))
-	var result []*resource.Resource
-	for _, r := range m.Resources() {
-		curId := r.CurId()
-		orgId := r.OrgId()
-
-		// matches the namespace when namespace is not empty in the selector
-		// It first tries to match with the original namespace
-		// then matches with the current namespace
-		if r.GetNamespace() != "" {
-			matched := ns.MatchString(orgId.EffectiveNamespace())
-			if !matched {
-				matched = ns.MatchString(curId.EffectiveNamespace())
-				if !matched {
-					continue
-				}
-			}
-		}
-
-		// matches the name when name is not empty in the selector
-		// It first tries to match with the original name
-		// then matches with the current name
-		if r.GetName() != "" {
-			matched := nm.MatchString(orgId.Name)
-			if !matched {
-				matched = nm.MatchString(curId.Name)
-				if !matched {
-					continue
-				}
-			}
-		}
-
-		// matches the GVK
-		if !r.GetGvk().IsSelected(&s.Gvk) {
-			continue
-		}
-
-		// matches the label selector
-		matched, err := r.MatchesLabelSelector(s.LabelSelector)
-		if err != nil {
-			return nil, err
-		}
-		if !matched {
-			continue
-		}
-
-		// matches the annotation selector
-		matched, err = r.MatchesAnnotationSelector(s.AnnotationSelector)
-		if err != nil {
-			return nil, err
-		}
-		if !matched {
-			continue
-		}
-		result = append(result, r)
-	}
-	return result, nil
-}

api/resmap/resmap_test.go

@@ -3,899 +3,4 @@
 
 package resmap_test
 
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-
-	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
-	"sigs.k8s.io/kustomize/api/resid"
-	. "sigs.k8s.io/kustomize/api/resmap"
-	"sigs.k8s.io/kustomize/api/resource"
-	resmaptest_test "sigs.k8s.io/kustomize/api/testutils/resmaptest"
-	"sigs.k8s.io/kustomize/api/types"
-)
-
-var rf = resource.NewFactory(
-	kunstruct.NewKunstructuredFactoryImpl())
-var rmF = NewFactory(rf, nil)
-
-func doAppend(t *testing.T, w ResMap, r *resource.Resource) {
-	err := w.Append(r)
-	if err != nil {
-		t.Fatalf("append error: %v", err)
-	}
-}
-func doRemove(t *testing.T, w ResMap, id resid.ResId) {
-	err := w.Remove(id)
-	if err != nil {
-		t.Fatalf("remove error: %v", err)
-	}
-}
-
-// Make a resource with a predictable name.
-func makeCm(i int) *resource.Resource {
-	return rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": fmt.Sprintf("cm%03d", i),
-			},
-		})
-}
-
-// Maintain the class invariant that no two
-// resources can have the same CurId().
-func TestAppendRejectsDuplicateResId(t *testing.T) {
-	w := New()
-	if err := w.Append(makeCm(1)); err != nil {
-		t.Fatalf("append error: %v", err)
-	}
-	err := w.Append(makeCm(1))
-	if err == nil {
-		t.Fatalf("expected append error")
-	}
-	if !strings.Contains(
-		err.Error(),
-		"may not add resource with an already registered id") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestAppendRemove(t *testing.T) {
-	w1 := New()
-	doAppend(t, w1, makeCm(1))
-	doAppend(t, w1, makeCm(2))
-	doAppend(t, w1, makeCm(3))
-	doAppend(t, w1, makeCm(4))
-	doAppend(t, w1, makeCm(5))
-	doAppend(t, w1, makeCm(6))
-	doAppend(t, w1, makeCm(7))
-	doRemove(t, w1, makeCm(1).OrgId())
-	doRemove(t, w1, makeCm(3).OrgId())
-	doRemove(t, w1, makeCm(5).OrgId())
-	doRemove(t, w1, makeCm(7).OrgId())
-
-	w2 := New()
-	doAppend(t, w2, makeCm(2))
-	doAppend(t, w2, makeCm(4))
-	doAppend(t, w2, makeCm(6))
-	if !reflect.DeepEqual(w1, w1) {
-		w1.Debug("w1")
-		w2.Debug("w2")
-		t.Fatalf("mismatch")
-	}
-
-	err := w2.Append(makeCm(6))
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-}
-
-func TestRemove(t *testing.T) {
-	w := New()
-	r := makeCm(1)
-	err := w.Remove(r.OrgId())
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	err = w.Append(r)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	err = w.Remove(r.OrgId())
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	err = w.Remove(r.OrgId())
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-}
-
-func TestReplace(t *testing.T) {
-	cm5 := makeCm(5)
-	cm700 := makeCm(700)
-	otherCm5 := makeCm(5)
-
-	w := New()
-	doAppend(t, w, makeCm(1))
-	doAppend(t, w, makeCm(2))
-	doAppend(t, w, makeCm(3))
-	doAppend(t, w, makeCm(4))
-	doAppend(t, w, cm5)
-	doAppend(t, w, makeCm(6))
-	doAppend(t, w, makeCm(7))
-
-	oldSize := w.Size()
-	_, err := w.Replace(otherCm5)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if w.Size() != oldSize {
-		t.Fatalf("unexpected size %d", w.Size())
-	}
-	if r, err := w.GetByCurrentId(cm5.OrgId()); err != nil || r != otherCm5 {
-		t.Fatalf("unexpected result r=%s, err=%v", r.CurId(), err)
-	}
-	if err := w.Append(cm5); err == nil {
-		t.Fatalf("expected id already there error")
-	}
-	if err := w.Remove(cm5.OrgId()); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	if err := w.Append(cm700); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	if err := w.Append(cm5); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-}
-
-func TestEncodeAsYaml(t *testing.T) {
-	encoded := []byte(`apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: cm1
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: cm2
-`)
-	input := resmaptest_test.NewRmBuilder(t, rf).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			},
-		}).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm2",
-			},
-		}).ResMap()
-	out, err := input.AsYaml()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !reflect.DeepEqual(out, encoded) {
-		t.Fatalf("%s doesn't match expected %s", out, encoded)
-	}
-}
-
-func TestGetMatchingResourcesByCurrentId(t *testing.T) {
-	r1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "alice",
-			},
-		})
-	r2 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "bob",
-			},
-		})
-	r3 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "bob",
-				"namespace": "happy",
-			},
-		})
-	r4 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "charlie",
-				"namespace": "happy",
-			},
-		})
-	r5 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name":      "charlie",
-				"namespace": "happy",
-			},
-		})
-
-	m := resmaptest_test.NewRmBuilder(t, rf).
-		AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).ResMap()
-
-	result := m.GetMatchingResourcesByCurrentId(
-		resid.NewResId(cmap, "alice").GvknEquals)
-	if len(result) != 1 {
-		t.Fatalf("Expected single map entry but got %v", result)
-	}
-	result = m.GetMatchingResourcesByCurrentId(
-		resid.NewResId(cmap, "bob").GvknEquals)
-	if len(result) != 2 {
-		t.Fatalf("Expected two, got %v", result)
-	}
-	result = m.GetMatchingResourcesByCurrentId(
-		resid.NewResIdWithNamespace(cmap, "bob", "system").GvknEquals)
-	if len(result) != 2 {
-		t.Fatalf("Expected two but got %v", result)
-	}
-	result = m.GetMatchingResourcesByCurrentId(
-		resid.NewResIdWithNamespace(cmap, "bob", "happy").Equals)
-	if len(result) != 1 {
-		t.Fatalf("Expected single map entry but got %v", result)
-	}
-	result = m.GetMatchingResourcesByCurrentId(
-		resid.NewResId(cmap, "charlie").GvknEquals)
-	if len(result) != 1 {
-		t.Fatalf("Expected single map entry but got %v", result)
-	}
-
-	// nolint:goconst
-	tests := []struct {
-		name    string
-		matcher IdMatcher
-		count   int
-	}{
-		{
-			"match everything",
-			func(resid.ResId) bool { return true },
-			5,
-		},
-		{
-			"match nothing",
-			func(resid.ResId) bool { return false },
-			0,
-		},
-		{
-			"name is alice",
-			func(x resid.ResId) bool { return x.Name == "alice" },
-			1,
-		},
-		{
-			"name is charlie",
-			func(x resid.ResId) bool { return x.Name == "charlie" },
-			2,
-		},
-		{
-			"name is bob",
-			func(x resid.ResId) bool { return x.Name == "bob" },
-			2,
-		},
-		{
-			"happy namespace",
-			func(x resid.ResId) bool {
-				return x.Namespace == "happy"
-			},
-			3,
-		},
-		{
-			"happy deployment",
-			func(x resid.ResId) bool {
-				return x.Namespace == "happy" &&
-					x.Gvk.Kind == "Deployment"
-			},
-			1,
-		},
-		{
-			"happy ConfigMap",
-			func(x resid.ResId) bool {
-				return x.Namespace == "happy" &&
-					x.Gvk.Kind == "ConfigMap"
-			},
-			2,
-		},
-	}
-	for _, tst := range tests {
-		result := m.GetMatchingResourcesByCurrentId(tst.matcher)
-		if len(result) != tst.count {
-			t.Fatalf("test '%s';  actual: %d, expected: %d",
-				tst.name, len(result), tst.count)
-		}
-	}
-}
-
-func TestSubsetThatCouldBeReferencedByResource(t *testing.T) {
-	r1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "alice",
-			},
-		})
-	r2 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "bob",
-			},
-		})
-	r3 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "bob",
-				"namespace": "happy",
-			},
-		})
-	r4 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name":      "charlie",
-				"namespace": "happy",
-			},
-		})
-	r5 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "charlie",
-				"namespace": "happy",
-			},
-		})
-	r5.AddNamePrefix("little-")
-	r6 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name":      "domino",
-				"namespace": "happy",
-			},
-		})
-	r6.AddNamePrefix("little-")
-	r7 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ClusterRoleBinding",
-			"metadata": map[string]interface{}{
-				"name": "meh",
-			},
-		})
-
-	tests := map[string]struct {
-		filter   *resource.Resource
-		expected ResMap
-	}{
-		"default namespace 1": {
-			filter: r2,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(r1).AddR(r2).AddR(r7).ResMap(),
-		},
-		"default namespace 2": {
-			filter: r1,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(r1).AddR(r2).AddR(r7).ResMap(),
-		},
-		"happy namespace no prefix": {
-			filter: r3,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
-		},
-		"happy namespace with prefix": {
-			filter: r5,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
-		},
-		"cluster level": {
-			filter: r7,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
-		},
-	}
-	m := resmaptest_test.NewRmBuilder(t, rf).
-		AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap()
-	for name, test := range tests {
-		test := test
-		t.Run(name, func(t *testing.T) {
-			got := m.SubsetThatCouldBeReferencedByResource(test.filter)
-			err := test.expected.ErrorIfNotEqualLists(got)
-			if err != nil {
-				test.expected.Debug("expected")
-				got.Debug("actual")
-				t.Fatalf("Expected match")
-			}
-		})
-	}
-}
-
-func addPfxSfx(r *resource.Resource, prefixes []string, suffixes []string) {
-	for _, pfx := range prefixes {
-		r.AddNamePrefix(pfx)
-	}
-
-	for _, sfx := range suffixes {
-		r.AddNameSuffix(sfx)
-	}
-}
-
-func TestSubsetThatCouldBeReferencedByResourceMultiLevel(t *testing.T) {
-	// Simulates ConfigMap and Deployment defined at level 1
-	// No prefix nor suffix added at that level
-	cm1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "level1",
-			},
-		})
-	addPfxSfx(cm1, []string{""}, []string{""})
-	dep1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "level1",
-			},
-		})
-	addPfxSfx(dep1, []string{""}, []string{""})
-
-	// Simulates ConfigMap and Deployment defined at level 1
-	// and prefix added in level 2 of kustomization
-	cm2p := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "level2p",
-			},
-		})
-	addPfxSfx(cm2p, []string{"", "level2p-"}, []string{"", ""})
-
-	dep2p := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "level2p",
-			},
-		})
-	addPfxSfx(dep2p, []string{"", "level2p-"}, []string{"", ""})
-
-	// Simulates ConfigMap and Deployment defined at level 1
-	// and suffix added in level 2 of kustomization
-	cm2s := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "level2s",
-			},
-		})
-	addPfxSfx(cm2s, []string{"", ""}, []string{"", "-level2s"})
-
-	dep2s := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "level2s",
-			},
-		})
-	addPfxSfx(dep2s, []string{"", ""}, []string{"", "-level2s"})
-
-	// Simulates ConfigMap and Deployment defined at level 1,
-	// prefix added in levels 2 and 3 of kustomization.
-	cm3e := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "level3e",
-			},
-		})
-	addPfxSfx(cm3e, []string{"", "level2p-", "level3e-"}, []string{"", "", ""})
-
-	dep3e := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "level3e",
-			},
-		})
-	addPfxSfx(dep3e, []string{"", "level2p-", "level3e-"}, []string{"", "", ""})
-
-	// Simulates Deployment defined at level 1, ConfigMap defined at level 2,
-	// prefix added in levels 2 and 3 of kustomization.
-	// This reproduce issue 1440.
-	cm3i := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "level3i",
-			},
-		})
-	addPfxSfx(cm3i, []string{"level2p-", "level3i-"}, []string{"", ""})
-
-	dep3i := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "level3i",
-			},
-		})
-	addPfxSfx(dep3i, []string{"", "level2p-", "level3i-"}, []string{"", "", ""})
-
-	tests := map[string]struct {
-		filter   *resource.Resource
-		expected ResMap
-	}{
-		"level1": {
-			filter: dep1,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(cm1).AddR(dep1).ResMap(),
-		},
-		"level2p": {
-			filter: dep2p,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(cm2p).AddR(dep2p).ResMap(),
-		},
-		"level2s": {
-			filter: dep2s,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(cm2s).AddR(dep2s).ResMap(),
-		},
-		"level3p": {
-			filter: dep3e,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(cm3e).AddR(dep3e).ResMap(),
-		},
-		"level3i": {
-			filter: dep3i,
-			expected: resmaptest_test.NewRmBuilder(t, rf).
-				AddR(cm3i).AddR(dep3i).ResMap(),
-		},
-	}
-	m := resmaptest_test.NewRmBuilder(t, rf).
-		AddR(cm1).AddR(dep1).AddR(cm2s).AddR(dep2s).AddR(cm2p).AddR(dep2p).AddR(cm3e).AddR(dep3e).AddR(cm3i).AddR(dep3i).ResMap()
-	for name, test := range tests {
-		test := test
-		t.Run(name, func(t *testing.T) {
-			got := m.SubsetThatCouldBeReferencedByResource(test.filter)
-			err := test.expected.ErrorIfNotEqualLists(got)
-			if err != nil {
-				test.expected.Debug("expected")
-				got.Debug("actual")
-				t.Fatalf("Expected match")
-			}
-		})
-	}
-}
-
-func TestDeepCopy(t *testing.T) {
-	rm1 := resmaptest_test.NewRmBuilder(t, rf).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			},
-		}).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm2",
-			},
-		}).ResMap()
-
-	rm2 := rm1.DeepCopy()
-
-	if &rm1 == &rm2 {
-		t.Fatal("DeepCopy returned a reference to itself instead of a copy")
-	}
-	err := rm1.ErrorIfNotEqualLists(rm1)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestErrorIfNotEqualSets(t *testing.T) {
-	r1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			},
-		})
-	r2 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm2",
-			},
-		})
-	r3 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "cm2",
-				"namespace": "system",
-			},
-		})
-
-	m1 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
-	if err := m1.ErrorIfNotEqualSets(m1); err != nil {
-		t.Fatalf("object should equal itself %v", err)
-	}
-
-	m2 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).ResMap()
-	if err := m1.ErrorIfNotEqualSets(m2); err == nil {
-		t.Fatalf("%v should not equal %v %v", m1, m2, err)
-	}
-
-	m3 := resmaptest_test.NewRmBuilder(t, rf).AddR(r2).ResMap()
-	if err := m2.ErrorIfNotEqualSets(m3); err == nil {
-		t.Fatalf("%v should not equal %v %v", m2, m3, err)
-	}
-
-	m3 = resmaptest_test.NewRmBuilder(t, rf).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			}}).ResMap()
-	if err := m2.ErrorIfNotEqualSets(m3); err != nil {
-		t.Fatalf("%v should equal %v %v", m2, m3, err)
-	}
-
-	m4 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
-	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-
-	m4 = resmaptest_test.NewRmBuilder(t, rf).AddR(r3).AddR(r1).AddR(r2).ResMap()
-	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-
-	m4 = m1.ShallowCopy()
-	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-	m4 = m1.DeepCopy()
-	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-}
-
-func TestErrorIfNotEqualLists(t *testing.T) {
-	r1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			},
-		})
-	r2 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm2",
-			},
-		})
-	r3 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name":      "cm2",
-				"namespace": "system",
-			},
-		})
-
-	m1 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
-	if err := m1.ErrorIfNotEqualLists(m1); err != nil {
-		t.Fatalf("object should equal itself %v", err)
-	}
-
-	m2 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).ResMap()
-	if err := m1.ErrorIfNotEqualLists(m2); err == nil {
-		t.Fatalf("%v should not equal %v %v", m1, m2, err)
-	}
-
-	m3 := resmaptest_test.NewRmBuilder(t, rf).Add(
-		map[string]interface{}{
-			"apiVersion": "v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cm1",
-			}}).ResMap()
-	if err := m2.ErrorIfNotEqualLists(m3); err != nil {
-		t.Fatalf("%v should equal %v %v", m2, m3, err)
-	}
-
-	m4 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
-	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-
-	m4 = resmaptest_test.NewRmBuilder(t, rf).AddR(r3).AddR(r1).AddR(r2).ResMap()
-	if err := m1.ErrorIfNotEqualLists(m4); err == nil {
-		t.Fatalf("expected inequality between %v and %v, %v", m1, m4, err)
-	}
-
-	m4 = m1.ShallowCopy()
-	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-	m4 = m1.DeepCopy()
-	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
-		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
-	}
-}
-
-func TestAppendAll(t *testing.T) {
-	r1 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "foo-deploy1",
-			},
-		})
-	input1 := rmF.FromResource(r1)
-	r2 := rf.FromMap(
-		map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "StatefulSet",
-			"metadata": map[string]interface{}{
-				"name": "bar-stateful",
-			},
-		})
-	input2 := rmF.FromResource(r2)
-
-	expected := New()
-	if err := expected.Append(r1); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := expected.Append(r2); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if err := input1.AppendAll(input2); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := expected.ErrorIfNotEqualLists(input1); err != nil {
-		input1.Debug("1")
-		expected.Debug("ex")
-		t.Fatalf("%#v doesn't equal expected %#v", input1, expected)
-	}
-	if err := input1.AppendAll(nil); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := expected.ErrorIfNotEqualLists(input1); err != nil {
-		t.Fatalf("%#v doesn't equal expected %#v", input1, expected)
-	}
-}
-
-func makeMap1() ResMap {
-	return rmF.FromResource(rf.FromMapAndOption(
-		map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cmap",
-			},
-			"data": map[string]interface{}{
-				"a": "x",
-				"b": "y",
-			},
-		}, &types.GeneratorArgs{
-			Behavior: "create",
-		}))
-}
-
-func makeMap2(b types.GenerationBehavior) ResMap {
-	return rmF.FromResource(rf.FromMapAndOption(
-		map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"name": "cmap",
-			},
-			"data": map[string]interface{}{
-				"a": "u",
-				"b": "v",
-				"c": "w",
-			},
-		}, &types.GeneratorArgs{
-			Behavior: b.String(),
-		}))
-}
-
-func TestAbsorbAll(t *testing.T) {
-	expected := rmF.FromResource(rf.FromMapAndOption(
-		map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "ConfigMap",
-			"metadata": map[string]interface{}{
-				"annotations": map[string]interface{}{},
-				"labels":      map[string]interface{}{},
-				"name":        "cmap",
-			},
-			"data": map[string]interface{}{
-				"a": "u",
-				"b": "v",
-				"c": "w",
-			},
-		}, &types.GeneratorArgs{
-			Behavior: "create",
-		}))
-	w := makeMap1()
-	if err := w.AbsorbAll(makeMap2(types.BehaviorMerge)); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := expected.ErrorIfNotEqualLists(w); err != nil {
-		t.Fatal(err)
-	}
-	w = makeMap1()
-	if err := w.AbsorbAll(nil); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := w.ErrorIfNotEqualLists(makeMap1()); err != nil {
-		t.Fatal(err)
-	}
-	w = makeMap1()
-	w2 := makeMap2(types.BehaviorReplace)
-	if err := w.AbsorbAll(w2); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if err := w2.ErrorIfNotEqualLists(w); err != nil {
-		t.Fatal(err)
-	}
-	w = makeMap1()
-	w2 = makeMap2(types.BehaviorUnspecified)
-	err := w.AbsorbAll(w2)
-	if err == nil {
-		t.Fatalf("expected error with unspecified behavior")
-	}
-}
+// See reswrangler_test.go

api/resmap/reswrangler.go

@@ -0,0 +1,563 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package resmap
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"sigs.k8s.io/kustomize/api/resid"
+	"sigs.k8s.io/kustomize/api/resource"
+	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/yaml"
+)
+
+// resWrangler implements ResMap.
+type resWrangler struct {
+	// Resource list maintained in load (append) order.
+	// This is important for transformers, which must
+	// be performed in a specific order, and for users
+	// who for whatever reasons wish the order they
+	// specify in kustomizations to be maintained and
+	// available as an option for final YAML rendering.
+	rList []*resource.Resource
+}
+
+func newOne() *resWrangler {
+	result := &resWrangler{}
+	result.Clear()
+	return result
+}
+
+// Clear implements ResMap.
+func (m *resWrangler) Clear() {
+	m.rList = nil
+}
+
+// Size implements ResMap.
+func (m *resWrangler) Size() int {
+	return len(m.rList)
+}
+
+func (m *resWrangler) indexOfResource(other *resource.Resource) int {
+	for i, r := range m.rList {
+		if r == other {
+			return i
+		}
+	}
+	return -1
+}
+
+// Resources implements ResMap.
+func (m *resWrangler) Resources() []*resource.Resource {
+	tmp := make([]*resource.Resource, len(m.rList))
+	copy(tmp, m.rList)
+	return tmp
+}
+
+// Append implements ResMap.
+func (m *resWrangler) Append(res *resource.Resource) error {
+	id := res.CurId()
+	if r := m.GetMatchingResourcesByCurrentId(id.Equals); len(r) > 0 {
+		return fmt.Errorf(
+			"may not add resource with an already registered id: %s", id)
+	}
+	m.rList = append(m.rList, res)
+	return nil
+}
+
+// Remove implements ResMap.
+func (m *resWrangler) Remove(adios resid.ResId) error {
+	tmp := newOne()
+	for _, r := range m.rList {
+		if r.CurId() != adios {
+			tmp.Append(r)
+		}
+	}
+	if tmp.Size() != m.Size()-1 {
+		return fmt.Errorf("id %s not found in removal", adios)
+	}
+	m.rList = tmp.rList
+	return nil
+}
+
+// Replace implements ResMap.
+func (m *resWrangler) Replace(res *resource.Resource) (int, error) {
+	id := res.CurId()
+	i, err := m.GetIndexOfCurrentId(id)
+	if err != nil {
+		return -1, errors.Wrap(err, "in Replace")
+	}
+	if i < 0 {
+		return -1, fmt.Errorf("cannot find resource with id %s to replace", id)
+	}
+	m.rList[i] = res
+	return i, nil
+}
+
+// AllIds implements ResMap.
+func (m *resWrangler) AllIds() (ids []resid.ResId) {
+	ids = make([]resid.ResId, m.Size())
+	for i, r := range m.rList {
+		ids[i] = r.CurId()
+	}
+	return
+}
+
+// Debug implements ResMap.
+func (m *resWrangler) Debug(title string) {
+	fmt.Println("--------------------------- " + title)
+	firstObj := true
+	for i, r := range m.rList {
+		if firstObj {
+			firstObj = false
+		} else {
+			fmt.Println("---")
+		}
+		fmt.Printf("# %d  %s\n", i, r.OrgId())
+		blob, err := yaml.Marshal(r.Map())
+		if err != nil {
+			panic(err)
+		}
+		fmt.Println(string(blob))
+	}
+}
+
+type IdMatcher func(resid.ResId) bool
+
+// GetByIndex implements ResMap.
+func (m *resWrangler) GetByIndex(i int) *resource.Resource {
+	if i < 0 || i >= m.Size() {
+		return nil
+	}
+	return m.rList[i]
+}
+
+// GetIndexOfCurrentId implements ResMap.
+func (m *resWrangler) GetIndexOfCurrentId(id resid.ResId) (int, error) {
+	count := 0
+	result := -1
+	for i, r := range m.rList {
+		if id.Equals(r.CurId()) {
+			count++
+			result = i
+		}
+	}
+	if count > 1 {
+		return -1, fmt.Errorf("id matched %d resources", count)
+	}
+	return result, nil
+}
+
+type IdFromResource func(r *resource.Resource) resid.ResId
+
+func GetOriginalId(r *resource.Resource) resid.ResId { return r.OrgId() }
+func GetCurrentId(r *resource.Resource) resid.ResId  { return r.CurId() }
+
+// GetMatchingResourcesByCurrentId implements ResMap.
+func (m *resWrangler) GetMatchingResourcesByCurrentId(
+	matches IdMatcher) []*resource.Resource {
+	return m.filteredById(matches, GetCurrentId)
+}
+
+// GetMatchingResourcesByOriginalId implements ResMap.
+func (m *resWrangler) GetMatchingResourcesByOriginalId(
+	matches IdMatcher) []*resource.Resource {
+	return m.filteredById(matches, GetOriginalId)
+}
+
+func (m *resWrangler) filteredById(
+	matches IdMatcher, idGetter IdFromResource) []*resource.Resource {
+	var result []*resource.Resource
+	for _, r := range m.rList {
+		if matches(idGetter(r)) {
+			result = append(result, r)
+		}
+	}
+	return result
+}
+
+// GetByCurrentId implements ResMap.
+func (m *resWrangler) GetByCurrentId(
+	id resid.ResId) (*resource.Resource, error) {
+	return demandOneMatch(m.GetMatchingResourcesByCurrentId, id, "Current")
+}
+
+// GetByOriginalId implements ResMap.
+func (m *resWrangler) GetByOriginalId(
+	id resid.ResId) (*resource.Resource, error) {
+	return demandOneMatch(m.GetMatchingResourcesByOriginalId, id, "Original")
+}
+
+// GetById implements ResMap.
+func (m *resWrangler) GetById(
+	id resid.ResId) (*resource.Resource, error) {
+	match, err1 := m.GetByOriginalId(id)
+	if err1 == nil {
+		return match, nil
+	}
+	match, err2 := m.GetByCurrentId(id)
+	if err2 == nil {
+		return match, nil
+	}
+	return nil, fmt.Errorf(
+		"%s; %s; failed to find unique target for patch %s",
+		err1.Error(), err2.Error(), id.GvknString())
+}
+
+type resFinder func(IdMatcher) []*resource.Resource
+
+func demandOneMatch(
+	f resFinder, id resid.ResId, s string) (*resource.Resource, error) {
+	r := f(id.Equals)
+	if len(r) == 1 {
+		return r[0], nil
+	}
+	if len(r) > 1 {
+		return nil, fmt.Errorf("multiple matches for %sId %s", s, id)
+	}
+	return nil, fmt.Errorf("no matches for %sId %s", s, id)
+}
+
+// GroupedByCurrentNamespace implements ResMap.GroupByCurrentNamespace
+func (m *resWrangler) GroupedByCurrentNamespace() map[string][]*resource.Resource {
+	items := m.groupedByCurrentNamespace()
+	delete(items, resid.TotallyNotANamespace)
+	return items
+}
+
+// NonNamespaceable implements ResMap.NonNamespaceable
+func (m *resWrangler) NonNamespaceable() []*resource.Resource {
+	return m.groupedByCurrentNamespace()[resid.TotallyNotANamespace]
+}
+
+func (m *resWrangler) groupedByCurrentNamespace() map[string][]*resource.Resource {
+	byNamespace := make(map[string][]*resource.Resource)
+	for _, res := range m.rList {
+		namespace := res.CurId().EffectiveNamespace()
+		if _, found := byNamespace[namespace]; !found {
+			byNamespace[namespace] = []*resource.Resource{}
+		}
+		byNamespace[namespace] = append(byNamespace[namespace], res)
+	}
+	return byNamespace
+}
+
+// GroupedByNamespace implements ResMap.GroupByOrginalNamespace
+func (m *resWrangler) GroupedByOriginalNamespace() map[string][]*resource.Resource {
+	items := m.groupedByOriginalNamespace()
+	delete(items, resid.TotallyNotANamespace)
+	return items
+}
+
+func (m *resWrangler) groupedByOriginalNamespace() map[string][]*resource.Resource {
+	byNamespace := make(map[string][]*resource.Resource)
+	for _, res := range m.rList {
+		namespace := res.OrgId().EffectiveNamespace()
+		if _, found := byNamespace[namespace]; !found {
+			byNamespace[namespace] = []*resource.Resource{}
+		}
+		byNamespace[namespace] = append(byNamespace[namespace], res)
+	}
+	return byNamespace
+}
+
+// AsYaml implements ResMap.
+func (m *resWrangler) AsYaml() ([]byte, error) {
+	firstObj := true
+	var b []byte
+	buf := bytes.NewBuffer(b)
+	for _, res := range m.Resources() {
+		out, err := yaml.Marshal(res.Map())
+		if err != nil {
+			return nil, err
+		}
+		if firstObj {
+			firstObj = false
+		} else {
+			if _, err = buf.WriteString("---\n"); err != nil {
+				return nil, err
+			}
+		}
+		if _, err = buf.Write(out); err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+// ErrorIfNotEqualSets implements ResMap.
+func (m *resWrangler) ErrorIfNotEqualSets(other ResMap) error {
+	m2, ok := other.(*resWrangler)
+	if !ok {
+		panic("bad cast")
+	}
+	if m.Size() != m2.Size() {
+		return fmt.Errorf(
+			"lists have different number of entries: %#v doesn't equal %#v",
+			m.rList, m2.rList)
+	}
+	seen := make(map[int]bool)
+	for _, r1 := range m.rList {
+		id := r1.CurId()
+		others := m2.GetMatchingResourcesByCurrentId(id.Equals)
+		if len(others) == 0 {
+			return fmt.Errorf(
+				"id in self missing from other; id: %s", id)
+		}
+		if len(others) > 1 {
+			return fmt.Errorf(
+				"id in self matches %d in other; id: %s", len(others), id)
+		}
+		r2 := others[0]
+		if !r1.KunstructEqual(r2) {
+			return fmt.Errorf(
+				"kunstruct not equal: \n -- %s,\n -- %s\n\n--\n%#v\n------\n%#v\n",
+				r1, r2, r1, r2)
+		}
+		seen[m2.indexOfResource(r2)] = true
+	}
+	if len(seen) != m.Size() {
+		return fmt.Errorf("counting problem %d != %d", len(seen), m.Size())
+	}
+	return nil
+}
+
+// ErrorIfNotEqualList implements ResMap.
+func (m *resWrangler) ErrorIfNotEqualLists(other ResMap) error {
+	m2, ok := other.(*resWrangler)
+	if !ok {
+		panic("bad cast")
+	}
+	if m.Size() != m2.Size() {
+		return fmt.Errorf(
+			"lists have different number of entries: %#v doesn't equal %#v",
+			m.rList, m2.rList)
+	}
+	for i, r1 := range m.rList {
+		r2 := m2.rList[i]
+		if !r1.Equals(r2) {
+			return fmt.Errorf(
+				"Item i=%d differs:\n  n1 = %s\n  n2 = %s\n  o1 = %s\n  o2 = %s\n",
+				i, r1.OrgId(), r2.OrgId(), r1, r2)
+		}
+	}
+	return nil
+}
+
+type resCopier func(r *resource.Resource) *resource.Resource
+
+// ShallowCopy implements ResMap.
+func (m *resWrangler) ShallowCopy() ResMap {
+	return m.makeCopy(
+		func(r *resource.Resource) *resource.Resource {
+			return r
+		})
+}
+
+// DeepCopy implements ResMap.
+func (m *resWrangler) DeepCopy() ResMap {
+	return m.makeCopy(
+		func(r *resource.Resource) *resource.Resource {
+			return r.DeepCopy()
+		})
+}
+
+// makeCopy copies the ResMap.
+func (m *resWrangler) makeCopy(copier resCopier) ResMap {
+	result := &resWrangler{}
+	result.rList = make([]*resource.Resource, m.Size())
+	for i, r := range m.rList {
+		result.rList[i] = copier(r)
+	}
+	return result
+}
+
+// SubsetThatCouldBeReferencedByResource implements ResMap.
+func (m *resWrangler) SubsetThatCouldBeReferencedByResource(
+	inputRes *resource.Resource) ResMap {
+	result := newOne()
+	inputId := inputRes.CurId()
+	isInputIdNamespaceable := inputId.IsNamespaceableKind()
+	subjectNamespaces := getNamespacesForRoleBinding(inputRes)
+	for _, r := range m.Resources() {
+		// Need to match more accuratly both at the time of selection and transformation.
+		// OutmostPrefixSuffixEquals is not accurate enough since it is only using
+		// the outer most suffix and the last prefix. Use PrefixedSuffixesEquals instead.
+		resId := r.CurId()
+		if !isInputIdNamespaceable || !resId.IsNamespaceableKind() || resId.IsNsEquals(inputId) ||
+			isRoleBindingNamespace(&subjectNamespaces, r.GetNamespace()) {
+			result.append(r)
+		}
+	}
+	return result
+}
+
+// isRoleBindingNamespace returns true is the namespace `ns` is in role binding
+// namespaces `m`
+func isRoleBindingNamespace(m *map[string]bool, ns string) bool {
+	return (*m)[ns]
+}
+
+// getNamespacesForRoleBinding returns referenced ServiceAccount namespaces if the inputRes is
+// a RoleBinding
+func getNamespacesForRoleBinding(inputRes *resource.Resource) map[string]bool {
+	res := make(map[string]bool)
+	if inputRes.GetKind() != "RoleBinding" {
+		return res
+	}
+	subjects, err := inputRes.GetSlice("subjects")
+	if err != nil || subjects == nil {
+		return res
+	}
+
+	for _, s := range subjects {
+		subject := s.(map[string]interface{})
+		if subject["namespace"] == nil || subject["kind"] == nil ||
+			subject["kind"].(string) != "ServiceAccount" {
+			continue
+		}
+		res[subject["namespace"].(string)] = true
+	}
+
+	return res
+}
+
+func (m *resWrangler) append(res *resource.Resource) {
+	m.rList = append(m.rList, res)
+}
+
+// AppendAll implements ResMap.
+func (m *resWrangler) AppendAll(other ResMap) error {
+	if other == nil {
+		return nil
+	}
+	for _, res := range other.Resources() {
+		if err := m.Append(res); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AbsorbAll implements ResMap.
+func (m *resWrangler) AbsorbAll(other ResMap) error {
+	if other == nil {
+		return nil
+	}
+	for _, r := range other.Resources() {
+		err := m.appendReplaceOrMerge(r)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (m *resWrangler) appendReplaceOrMerge(
+	res *resource.Resource) error {
+	id := res.CurId()
+	matches := m.GetMatchingResourcesByOriginalId(id.Equals)
+	if len(matches) == 0 {
+		matches = m.GetMatchingResourcesByCurrentId(id.Equals)
+	}
+	switch len(matches) {
+	case 0:
+		switch res.Behavior() {
+		case types.BehaviorMerge, types.BehaviorReplace:
+			return fmt.Errorf(
+				"id %#v does not exist; cannot merge or replace", id)
+		default:
+			// presumably types.BehaviorCreate
+			err := m.Append(res)
+			if err != nil {
+				return err
+			}
+		}
+	case 1:
+		old := matches[0]
+		if old == nil {
+			return fmt.Errorf("id lookup failure")
+		}
+		index := m.indexOfResource(old)
+		if index < 0 {
+			return fmt.Errorf("indexing problem")
+		}
+		switch res.Behavior() {
+		case types.BehaviorReplace:
+			res.Replace(old)
+		case types.BehaviorMerge:
+			res.Merge(old)
+		default:
+			return fmt.Errorf(
+				"id %#v exists; behavior must be merge or replace", id)
+		}
+		i, err := m.Replace(res)
+		if err != nil {
+			return err
+		}
+		if i != index {
+			return fmt.Errorf("unexpected index in replacement")
+		}
+	default:
+		return fmt.Errorf(
+			"found multiple objects %v that could accept merge of %v",
+			matches, id)
+	}
+	return nil
+}
+
+// Select returns a list of resources that
+// are selected by a Selector
+func (m *resWrangler) Select(s types.Selector) ([]*resource.Resource, error) {
+	var result []*resource.Resource
+	sr, err := types.NewSelectorRegex(&s)
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range m.Resources() {
+		curId := r.CurId()
+		orgId := r.OrgId()
+
+		// It first tries to match with the original namespace
+		// then matches with the current namespace
+		if !sr.MatchNamespace(orgId.EffectiveNamespace()) &&
+			!sr.MatchNamespace(curId.EffectiveNamespace()) {
+			continue
+		}
+
+		// It first tries to match with the original name
+		// then matches with the current name
+		if !sr.MatchName(orgId.Name) &&
+			!sr.MatchName(curId.Name) {
+			continue
+		}
+
+		// matches the GVK
+		if !sr.MatchGvk(r.GetGvk()) {
+			continue
+		}
+
+		// matches the label selector
+		matched, err := r.MatchesLabelSelector(s.LabelSelector)
+		if err != nil {
+			return nil, err
+		}
+		if !matched {
+			continue
+		}
+
+		// matches the annotation selector
+		matched, err = r.MatchesAnnotationSelector(s.AnnotationSelector)
+		if err != nil {
+			return nil, err
+		}
+		if !matched {
+			continue
+		}
+		result = append(result, r)
+	}
+	return result, nil
+}

api/resmap/reswrangler_test.go

@@ -0,0 +1,734 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package resmap_test
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"sigs.k8s.io/kustomize/api/k8sdeps/kunstruct"
+	"sigs.k8s.io/kustomize/api/resid"
+	. "sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/resource"
+	resmaptest_test "sigs.k8s.io/kustomize/api/testutils/resmaptest"
+	"sigs.k8s.io/kustomize/api/types"
+)
+
+var rf = resource.NewFactory(
+	kunstruct.NewKunstructuredFactoryImpl())
+var rmF = NewFactory(rf, nil)
+
+func doAppend(t *testing.T, w ResMap, r *resource.Resource) {
+	err := w.Append(r)
+	if err != nil {
+		t.Fatalf("append error: %v", err)
+	}
+}
+func doRemove(t *testing.T, w ResMap, id resid.ResId) {
+	err := w.Remove(id)
+	if err != nil {
+		t.Fatalf("remove error: %v", err)
+	}
+}
+
+// Make a resource with a predictable name.
+func makeCm(i int) *resource.Resource {
+	return rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": fmt.Sprintf("cm%03d", i),
+			},
+		})
+}
+
+// Maintain the class invariant that no two
+// resources can have the same CurId().
+func TestAppendRejectsDuplicateResId(t *testing.T) {
+	w := New()
+	if err := w.Append(makeCm(1)); err != nil {
+		t.Fatalf("append error: %v", err)
+	}
+	err := w.Append(makeCm(1))
+	if err == nil {
+		t.Fatalf("expected append error")
+	}
+	if !strings.Contains(
+		err.Error(),
+		"may not add resource with an already registered id") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestAppendRemove(t *testing.T) {
+	w1 := New()
+	doAppend(t, w1, makeCm(1))
+	doAppend(t, w1, makeCm(2))
+	doAppend(t, w1, makeCm(3))
+	doAppend(t, w1, makeCm(4))
+	doAppend(t, w1, makeCm(5))
+	doAppend(t, w1, makeCm(6))
+	doAppend(t, w1, makeCm(7))
+	doRemove(t, w1, makeCm(1).OrgId())
+	doRemove(t, w1, makeCm(3).OrgId())
+	doRemove(t, w1, makeCm(5).OrgId())
+	doRemove(t, w1, makeCm(7).OrgId())
+
+	w2 := New()
+	doAppend(t, w2, makeCm(2))
+	doAppend(t, w2, makeCm(4))
+	doAppend(t, w2, makeCm(6))
+	if !reflect.DeepEqual(w1, w1) {
+		w1.Debug("w1")
+		w2.Debug("w2")
+		t.Fatalf("mismatch")
+	}
+
+	err := w2.Append(makeCm(6))
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+func TestRemove(t *testing.T) {
+	w := New()
+	r := makeCm(1)
+	err := w.Remove(r.OrgId())
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	err = w.Append(r)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	err = w.Remove(r.OrgId())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	err = w.Remove(r.OrgId())
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+func TestReplace(t *testing.T) {
+	cm5 := makeCm(5)
+	cm700 := makeCm(700)
+	otherCm5 := makeCm(5)
+
+	w := New()
+	doAppend(t, w, makeCm(1))
+	doAppend(t, w, makeCm(2))
+	doAppend(t, w, makeCm(3))
+	doAppend(t, w, makeCm(4))
+	doAppend(t, w, cm5)
+	doAppend(t, w, makeCm(6))
+	doAppend(t, w, makeCm(7))
+
+	oldSize := w.Size()
+	_, err := w.Replace(otherCm5)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if w.Size() != oldSize {
+		t.Fatalf("unexpected size %d", w.Size())
+	}
+	if r, err := w.GetByCurrentId(cm5.OrgId()); err != nil || r != otherCm5 {
+		t.Fatalf("unexpected result r=%s, err=%v", r.CurId(), err)
+	}
+	if err := w.Append(cm5); err == nil {
+		t.Fatalf("expected id already there error")
+	}
+	if err := w.Remove(cm5.OrgId()); err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if err := w.Append(cm700); err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if err := w.Append(cm5); err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+}
+
+func TestEncodeAsYaml(t *testing.T) {
+	encoded := []byte(`apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: cm1
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: cm2
+`)
+	input := resmaptest_test.NewRmBuilder(t, rf).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			},
+		}).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm2",
+			},
+		}).ResMap()
+	out, err := input.AsYaml()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(out, encoded) {
+		t.Fatalf("%s doesn't match expected %s", out, encoded)
+	}
+}
+
+func TestGetMatchingResourcesByCurrentId(t *testing.T) {
+	r1 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "alice",
+			},
+		})
+	r2 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "bob",
+			},
+		})
+	r3 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "bob",
+				"namespace": "happy",
+			},
+		})
+	r4 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "charlie",
+				"namespace": "happy",
+			},
+		})
+	r5 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "Deployment",
+			"metadata": map[string]interface{}{
+				"name":      "charlie",
+				"namespace": "happy",
+			},
+		})
+
+	m := resmaptest_test.NewRmBuilder(t, rf).
+		AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).ResMap()
+
+	result := m.GetMatchingResourcesByCurrentId(
+		resid.NewResId(cmap, "alice").GvknEquals)
+	if len(result) != 1 {
+		t.Fatalf("Expected single map entry but got %v", result)
+	}
+	result = m.GetMatchingResourcesByCurrentId(
+		resid.NewResId(cmap, "bob").GvknEquals)
+	if len(result) != 2 {
+		t.Fatalf("Expected two, got %v", result)
+	}
+	result = m.GetMatchingResourcesByCurrentId(
+		resid.NewResIdWithNamespace(cmap, "bob", "system").GvknEquals)
+	if len(result) != 2 {
+		t.Fatalf("Expected two but got %v", result)
+	}
+	result = m.GetMatchingResourcesByCurrentId(
+		resid.NewResIdWithNamespace(cmap, "bob", "happy").Equals)
+	if len(result) != 1 {
+		t.Fatalf("Expected single map entry but got %v", result)
+	}
+	result = m.GetMatchingResourcesByCurrentId(
+		resid.NewResId(cmap, "charlie").GvknEquals)
+	if len(result) != 1 {
+		t.Fatalf("Expected single map entry but got %v", result)
+	}
+
+	// nolint:goconst
+	tests := []struct {
+		name    string
+		matcher IdMatcher
+		count   int
+	}{
+		{
+			"match everything",
+			func(resid.ResId) bool { return true },
+			5,
+		},
+		{
+			"match nothing",
+			func(resid.ResId) bool { return false },
+			0,
+		},
+		{
+			"name is alice",
+			func(x resid.ResId) bool { return x.Name == "alice" },
+			1,
+		},
+		{
+			"name is charlie",
+			func(x resid.ResId) bool { return x.Name == "charlie" },
+			2,
+		},
+		{
+			"name is bob",
+			func(x resid.ResId) bool { return x.Name == "bob" },
+			2,
+		},
+		{
+			"happy namespace",
+			func(x resid.ResId) bool {
+				return x.Namespace == "happy"
+			},
+			3,
+		},
+		{
+			"happy deployment",
+			func(x resid.ResId) bool {
+				return x.Namespace == "happy" &&
+					x.Gvk.Kind == "Deployment"
+			},
+			1,
+		},
+		{
+			"happy ConfigMap",
+			func(x resid.ResId) bool {
+				return x.Namespace == "happy" &&
+					x.Gvk.Kind == "ConfigMap"
+			},
+			2,
+		},
+	}
+	for _, tst := range tests {
+		result := m.GetMatchingResourcesByCurrentId(tst.matcher)
+		if len(result) != tst.count {
+			t.Fatalf("test '%s';  actual: %d, expected: %d",
+				tst.name, len(result), tst.count)
+		}
+	}
+}
+
+func TestSubsetThatCouldBeReferencedByResource(t *testing.T) {
+	r1 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "alice",
+			},
+		})
+	r2 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "bob",
+			},
+		})
+	r3 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "bob",
+				"namespace": "happy",
+			},
+		})
+	r4 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "Deployment",
+			"metadata": map[string]interface{}{
+				"name":      "charlie",
+				"namespace": "happy",
+			},
+		})
+	r5 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "charlie",
+				"namespace": "happy",
+			},
+		})
+	r5.AddNamePrefix("little-")
+	r6 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "Deployment",
+			"metadata": map[string]interface{}{
+				"name":      "domino",
+				"namespace": "happy",
+			},
+		})
+	r6.AddNamePrefix("little-")
+	r7 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "rbac.authorization.k8s.io/v1",
+			"kind":       "ClusterRoleBinding",
+			"metadata": map[string]interface{}{
+				"name": "meh",
+			},
+		})
+
+	tests := map[string]struct {
+		filter   *resource.Resource
+		expected ResMap
+	}{
+		"default namespace 1": {
+			filter: r2,
+			expected: resmaptest_test.NewRmBuilder(t, rf).
+				AddR(r1).AddR(r2).AddR(r7).ResMap(),
+		},
+		"default namespace 2": {
+			filter: r1,
+			expected: resmaptest_test.NewRmBuilder(t, rf).
+				AddR(r1).AddR(r2).AddR(r7).ResMap(),
+		},
+		"happy namespace no prefix": {
+			filter: r3,
+			expected: resmaptest_test.NewRmBuilder(t, rf).
+				AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
+		},
+		"happy namespace with prefix": {
+			filter: r5,
+			expected: resmaptest_test.NewRmBuilder(t, rf).
+				AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
+		},
+		"cluster level": {
+			filter: r7,
+			expected: resmaptest_test.NewRmBuilder(t, rf).
+				AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap(),
+		},
+	}
+	m := resmaptest_test.NewRmBuilder(t, rf).
+		AddR(r1).AddR(r2).AddR(r3).AddR(r4).AddR(r5).AddR(r6).AddR(r7).ResMap()
+	for name, test := range tests {
+		test := test
+		t.Run(name, func(t *testing.T) {
+			got := m.SubsetThatCouldBeReferencedByResource(test.filter)
+			err := test.expected.ErrorIfNotEqualLists(got)
+			if err != nil {
+				test.expected.Debug("expected")
+				got.Debug("actual")
+				t.Fatalf("Expected match")
+			}
+		})
+	}
+}
+
+func TestDeepCopy(t *testing.T) {
+	rm1 := resmaptest_test.NewRmBuilder(t, rf).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			},
+		}).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm2",
+			},
+		}).ResMap()
+
+	rm2 := rm1.DeepCopy()
+
+	if &rm1 == &rm2 {
+		t.Fatal("DeepCopy returned a reference to itself instead of a copy")
+	}
+	err := rm1.ErrorIfNotEqualLists(rm1)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestErrorIfNotEqualSets(t *testing.T) {
+	r1 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			},
+		})
+	r2 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm2",
+			},
+		})
+	r3 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "cm2",
+				"namespace": "system",
+			},
+		})
+
+	m1 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
+	if err := m1.ErrorIfNotEqualSets(m1); err != nil {
+		t.Fatalf("object should equal itself %v", err)
+	}
+
+	m2 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).ResMap()
+	if err := m1.ErrorIfNotEqualSets(m2); err == nil {
+		t.Fatalf("%v should not equal %v %v", m1, m2, err)
+	}
+
+	m3 := resmaptest_test.NewRmBuilder(t, rf).AddR(r2).ResMap()
+	if err := m2.ErrorIfNotEqualSets(m3); err == nil {
+		t.Fatalf("%v should not equal %v %v", m2, m3, err)
+	}
+
+	m3 = resmaptest_test.NewRmBuilder(t, rf).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			}}).ResMap()
+	if err := m2.ErrorIfNotEqualSets(m3); err != nil {
+		t.Fatalf("%v should equal %v %v", m2, m3, err)
+	}
+
+	m4 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
+	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+
+	m4 = resmaptest_test.NewRmBuilder(t, rf).AddR(r3).AddR(r1).AddR(r2).ResMap()
+	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+
+	m4 = m1.ShallowCopy()
+	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+	m4 = m1.DeepCopy()
+	if err := m1.ErrorIfNotEqualSets(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+}
+
+func TestErrorIfNotEqualLists(t *testing.T) {
+	r1 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			},
+		})
+	r2 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm2",
+			},
+		})
+	r3 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name":      "cm2",
+				"namespace": "system",
+			},
+		})
+
+	m1 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
+	if err := m1.ErrorIfNotEqualLists(m1); err != nil {
+		t.Fatalf("object should equal itself %v", err)
+	}
+
+	m2 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).ResMap()
+	if err := m1.ErrorIfNotEqualLists(m2); err == nil {
+		t.Fatalf("%v should not equal %v %v", m1, m2, err)
+	}
+
+	m3 := resmaptest_test.NewRmBuilder(t, rf).Add(
+		map[string]interface{}{
+			"apiVersion": "v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cm1",
+			}}).ResMap()
+	if err := m2.ErrorIfNotEqualLists(m3); err != nil {
+		t.Fatalf("%v should equal %v %v", m2, m3, err)
+	}
+
+	m4 := resmaptest_test.NewRmBuilder(t, rf).AddR(r1).AddR(r2).AddR(r3).ResMap()
+	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+
+	m4 = resmaptest_test.NewRmBuilder(t, rf).AddR(r3).AddR(r1).AddR(r2).ResMap()
+	if err := m1.ErrorIfNotEqualLists(m4); err == nil {
+		t.Fatalf("expected inequality between %v and %v, %v", m1, m4, err)
+	}
+
+	m4 = m1.ShallowCopy()
+	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+	m4 = m1.DeepCopy()
+	if err := m1.ErrorIfNotEqualLists(m4); err != nil {
+		t.Fatalf("expected equality between %v and %v, %v", m1, m4, err)
+	}
+}
+
+func TestAppendAll(t *testing.T) {
+	r1 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "Deployment",
+			"metadata": map[string]interface{}{
+				"name": "foo-deploy1",
+			},
+		})
+	input1 := rmF.FromResource(r1)
+	r2 := rf.FromMap(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "StatefulSet",
+			"metadata": map[string]interface{}{
+				"name": "bar-stateful",
+			},
+		})
+	input2 := rmF.FromResource(r2)
+
+	expected := New()
+	if err := expected.Append(r1); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := expected.Append(r2); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if err := input1.AppendAll(input2); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := expected.ErrorIfNotEqualLists(input1); err != nil {
+		input1.Debug("1")
+		expected.Debug("ex")
+		t.Fatalf("%#v doesn't equal expected %#v", input1, expected)
+	}
+	if err := input1.AppendAll(nil); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := expected.ErrorIfNotEqualLists(input1); err != nil {
+		t.Fatalf("%#v doesn't equal expected %#v", input1, expected)
+	}
+}
+
+func makeMap1() ResMap {
+	return rmF.FromResource(rf.FromMapAndOption(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cmap",
+			},
+			"data": map[string]interface{}{
+				"a": "x",
+				"b": "y",
+			},
+		}, &types.GeneratorArgs{
+			Behavior: "create",
+		}))
+}
+
+func makeMap2(b types.GenerationBehavior) ResMap {
+	return rmF.FromResource(rf.FromMapAndOption(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"name": "cmap",
+			},
+			"data": map[string]interface{}{
+				"a": "u",
+				"b": "v",
+				"c": "w",
+			},
+		}, &types.GeneratorArgs{
+			Behavior: b.String(),
+		}))
+}
+
+func TestAbsorbAll(t *testing.T) {
+	expected := rmF.FromResource(rf.FromMapAndOption(
+		map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "ConfigMap",
+			"metadata": map[string]interface{}{
+				"annotations": map[string]interface{}{},
+				"labels":      map[string]interface{}{},
+				"name":        "cmap",
+			},
+			"data": map[string]interface{}{
+				"a": "u",
+				"b": "v",
+				"c": "w",
+			},
+		}, &types.GeneratorArgs{
+			Behavior: "create",
+		}))
+	w := makeMap1()
+	if err := w.AbsorbAll(makeMap2(types.BehaviorMerge)); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := expected.ErrorIfNotEqualLists(w); err != nil {
+		t.Fatal(err)
+	}
+	w = makeMap1()
+	if err := w.AbsorbAll(nil); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := w.ErrorIfNotEqualLists(makeMap1()); err != nil {
+		t.Fatal(err)
+	}
+	w = makeMap1()
+	w2 := makeMap2(types.BehaviorReplace)
+	if err := w.AbsorbAll(w2); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if err := w2.ErrorIfNotEqualLists(w); err != nil {
+		t.Fatal(err)
+	}
+	w = makeMap1()
+	w2 = makeMap2(types.BehaviorUnspecified)
+	err := w.AbsorbAll(w2)
+	if err == nil {
+		t.Fatalf("expected error with unspecified behavior")
+	}
+}

api/resmap/selector_test.go

@@ -164,6 +164,18 @@ func TestFindPatchTargets(t *testing.T) {
 			},
 			count: 2,
 		},
+		{
+			target: types.Selector{
+				Namespace: "NotMatched",
+			},
+			count: 0,
+		},
+		{
+			target: types.Selector{
+				Namespace: "ns1",
+			},
+			count: 1,
+		},
 	}
 	for _, testcase := range testcases {
 		actual, err := rm.Select(testcase.target)

api/resource/resource.go

@@ -68,6 +68,10 @@ func (r *Resource) GetString(p string) (string, error) {
 	return r.kunStr.GetString(p)
 }
 
+func (r *Resource) IsEmpty() bool {
+	return len(r.kunStr.Map()) == 0
+}
+
 func (r *Resource) Map() map[string]interface{} {
 	return r.kunStr.Map()
 }
@@ -277,12 +281,6 @@ func (r *Resource) PrefixesSuffixesEquals(o ResCtx) bool {
 	return sameEndingSubarray(r.GetNamePrefixes(), o.GetNamePrefixes()) && sameEndingSubarray(r.GetNameSuffixes(), o.GetNameSuffixes())
 }
 
-// This is used to compute if a referrer could potentially be impacted
-// by the change of name of a referral.
-func (r *Resource) InSameKustomizeCtx(rctxm ResCtxMatcher) bool {
-	return rctxm(r)
-}
-
 func (r *Resource) GetOriginalName() string {
 	return r.originalName
 }

api/testutils/kusttest/harness.go

@@ -16,7 +16,7 @@ import (
 	"sigs.k8s.io/kustomize/api/types"
 )
 
-// Harness manages a kustomize environment for tests.
+// Harness manages a test environment.
 type Harness struct {
 	t    *testing.T
 	fSys filesys.FileSystem
@@ -72,15 +72,12 @@ func (th Harness) MakeDefaultOptions() krusty.Options {
 
 // This has no impact on Builtin plugins, as they are always enabled.
 func (th Harness) MakeOptionsPluginsDisabled() krusty.Options {
-	return krusty.Options{
-		LoadRestrictions: types.LoadRestrictionsRootOnly,
-		PluginConfig:     konfig.DisabledPluginConfig(),
-	}
+	return *krusty.MakeDefaultOptions()
 }
 
 // Enables use of non-builtin plugins.
 func (th Harness) MakeOptionsPluginsEnabled() krusty.Options {
-	c, err := konfig.EnabledPluginConfig(types.BploLoadFromFileSys)
+	pc, err := konfig.EnabledPluginConfig(types.BploLoadFromFileSys)
 	if err != nil {
 		if strings.Contains(err.Error(), "unable to find plugin root") {
 			th.t.Log(
@@ -89,10 +86,9 @@ func (th Harness) MakeOptionsPluginsEnabled() krusty.Options {
 		}
 		th.t.Fatal(err)
 	}
-	return krusty.Options{
-		LoadRestrictions: types.LoadRestrictionsRootOnly,
-		PluginConfig:     c,
-	}
+	o := *krusty.MakeDefaultOptions()
+	o.PluginConfig = pc
+	return o
 }
 
 // Run, failing on error.

api/types/helmchartargs.go

@@ -0,0 +1,19 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package types
+
+// HelmChartArgs contains the metadata of how to generate a secret.
+type HelmChartArgs struct {
+	ChartName    string `json:"chartName,omitempty" yaml:"chartName,omitempty"`
+	ChartVersion string `json:"chartVersion,omitempty" yaml:"chartVersion,omitempty"`
+	ChartRepoURL string `json:"chartRepoUrl,omitempty" yaml:"chartRepoUrl,omitempty"`
+	ChartHome    string `json:"chartHome,omitempty" yaml:"chartHome,omitempty"`
+	// Use chartRelease to keep compatible with old exec plugin
+	ChartRepoName    string `json:"chartRelease,omitempty" yaml:"chartRelease,omitempty"`
+	HelmBin          string `json:"helmBin,omitempty" yaml:"helmBin,omitempty"`
+	HelmHome         string `json:"helmHome,omitempty" yaml:"helmHome,omitempty"`
+	Values           string `json:"values,omitempty" yaml:"values,omitempty"`
+	ReleaseName      string `json:"releaseName,omitempty" yaml:"releaseName,omitempty"`
+	ReleaseNamespace string `json:"releaseNamespace,omitempty" yaml:"releaseNamespace,omitempty"`
+}

api/types/kustomization.go

@@ -22,6 +22,9 @@ const (
 type Kustomization struct {
 	TypeMeta `json:",inline" yaml:",inline"`
 
+	// MetaData is a pointer to avoid marshalling empty struct
+	MetaData *ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty"`
+
 	//
 	// Operators - what kustomize can do.
 	//
@@ -52,7 +55,7 @@ type Kustomization struct {
 	// JSONPatches is a list of JSONPatch for applying JSON patch.
 	// Format documented at https://tools.ietf.org/html/rfc6902
 	// and http://jsonpatch.com
-	PatchesJson6902 []PatchJson6902 `json:"patchesJson6902,omitempty" yaml:"patchesJson6902,omitempty"`
+	PatchesJson6902 []Patch `json:"patchesJson6902,omitempty" yaml:"patchesJson6902,omitempty"`
 
 	// Patches is a list of patches, where each one can be either a
 	// Strategic Merge Patch or a JSON patch.
@@ -119,6 +122,11 @@ type Kustomization struct {
 	// the map will have a suffix hash generated from its contents.
 	SecretGenerator []SecretArgs `json:"secretGenerator,omitempty" yaml:"secretGenerator,omitempty"`
 
+	// HelmChartInflationGenerator is a list of helm chart configurations.
+	// The resulting resource is a normal operand rendered from
+	// a remote chart by `helm template`
+	HelmChartInflationGenerator []HelmChartArgs `json:"helmChartInflationGenerator,omitempty" yaml:"helmChartInflationGenerator,omitempty"`
+
 	// GeneratorOptions modify behavior of all ConfigMap and Secret generators.
 	GeneratorOptions *GeneratorOptions `json:"generatorOptions,omitempty" yaml:"generatorOptions,omitempty"`
 
@@ -164,9 +172,7 @@ func (k *Kustomization) FixKustomizationPostUnmarshalling() {
 // has been processed.
 func (k *Kustomization) FixKustomizationPreMarshalling() {
 	// PatchesJson6902 should be under the Patches field.
-	for _, patch := range k.PatchesJson6902 {
-		k.Patches = append(k.Patches, patch.ToPatch())
-	}
+	k.Patches = append(k.Patches, k.PatchesJson6902...)
 	k.PatchesJson6902 = nil
 }
 

api/types/kustomization_test.go

@@ -141,6 +141,13 @@ func TestUnmarshal(t *testing.T) {
 	y := []byte(`
 apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
+metadata:
+  name: kust
+  namespace: default
+  labels:
+    foo: bar
+  annotations:
+    foo: bar
 resources:
 - foo
 - bar
@@ -151,8 +158,20 @@ namePrefix: cat`)
 	if err != nil {
 		t.Fatal(err)
 	}
+	meta := ObjectMeta{
+		Name:      "kust",
+		Namespace: "default",
+		Labels: map[string]string{
+			"foo": "bar",
+		},
+		Annotations: map[string]string{
+			"foo": "bar",
+		},
+	}
 	if k.Kind != KustomizationKind || k.APIVersion != KustomizationVersion ||
-		len(k.Resources) != 2 || k.NamePrefix != "cat" || k.NameSuffix != "dog" {
+		len(k.Resources) != 2 || k.NamePrefix != "cat" || k.NameSuffix != "dog" ||
+		k.MetaData.Name != meta.Name || k.MetaData.Namespace != meta.Namespace ||
+		k.MetaData.Labels["foo"] != meta.Labels["foo"] || k.MetaData.Annotations["foo"] != meta.Annotations["foo"] {
 		t.Fatalf("wrong unmarshal result: %v", k)
 	}
 }

api/types/objectmeta.go

@@ -6,6 +6,8 @@ package types
 // ObjectMeta partially copies apimachinery/pkg/apis/meta/v1.ObjectMeta
 // No need for a direct dependence; the fields are stable.
 type ObjectMeta struct {
-	Name      string `json:"name,omitempty" yaml:"name,omitempty"`
-	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
+	Name        string            `json:"name,omitempty" yaml:"name,omitempty"`
+	Namespace   string            `json:"namespace,omitempty" yaml:"namespace,omitempty"`
+	Labels      map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
+	Annotations map[string]string `json:"annotations,omitempty" yaml:"annotations,omitempty"`
 }

api/types/patch.go

@@ -17,3 +17,12 @@ type Patch struct {
 	// Target points to the resources that the patch is applied to
 	Target *Selector `json:"target,omitempty" yaml:"target,omitempty"`
 }
+
+// Equals return true if p equals o.
+func (p *Patch) Equals(o Patch) bool {
+	targetEqual := (p.Target == o.Target) ||
+		(p.Target != nil && o.Target != nil && *p.Target == *o.Target)
+	return p.Path == o.Path &&
+		p.Patch == o.Patch &&
+		targetEqual
+}

api/types/patch_test.go

@@ -0,0 +1,125 @@
+package types_test
+
+import (
+	"testing"
+
+	"sigs.k8s.io/kustomize/api/resid"
+	. "sigs.k8s.io/kustomize/api/types"
+)
+
+func TestPatchEquals(t *testing.T) {
+	selector := Selector{
+		Gvk: resid.Gvk{
+			Group:   "group",
+			Version: "version",
+			Kind:    "kind",
+		},
+		Name:               "name",
+		Namespace:          "namespace",
+		LabelSelector:      "selector",
+		AnnotationSelector: "selector",
+	}
+	type testcase struct {
+		patch1 Patch
+		patch2 Patch
+		expect bool
+		name   string
+	}
+	testcases := []testcase{
+		{
+			name:   "empty patches",
+			patch1: Patch{},
+			patch2: Patch{},
+			expect: true,
+		},
+		{
+			name: "full patches",
+			patch1: Patch{
+				Path:  "foo",
+				Patch: "bar",
+				Target: &Selector{
+					Gvk: resid.Gvk{
+						Group:   "group",
+						Version: "version",
+						Kind:    "kind",
+					},
+					Name:               "name",
+					Namespace:          "namespace",
+					LabelSelector:      "selector",
+					AnnotationSelector: "selector",
+				},
+			},
+			patch2: Patch{
+				Path:  "foo",
+				Patch: "bar",
+				Target: &Selector{
+					Gvk: resid.Gvk{
+						Group:   "group",
+						Version: "version",
+						Kind:    "kind",
+					},
+					Name:               "name",
+					Namespace:          "namespace",
+					LabelSelector:      "selector",
+					AnnotationSelector: "selector",
+				},
+			},
+			expect: true,
+		},
+		{
+			name: "same target",
+			patch1: Patch{
+				Path:   "foo",
+				Patch:  "bar",
+				Target: &selector,
+			},
+			patch2: Patch{
+				Path:   "foo",
+				Patch:  "bar",
+				Target: &selector,
+			},
+			expect: true,
+		},
+		{
+			name: "omit target",
+			patch1: Patch{
+				Path:  "foo",
+				Patch: "bar",
+			},
+			patch2: Patch{
+				Path:  "foo",
+				Patch: "bar",
+			},
+			expect: true,
+		},
+		{
+			name: "one nil target",
+			patch1: Patch{
+				Path:   "foo",
+				Patch:  "bar",
+				Target: &selector,
+			},
+			patch2: Patch{
+				Path:  "foo",
+				Patch: "bar",
+			},
+			expect: false,
+		},
+		{
+			name: "different path",
+			patch1: Patch{
+				Path: "foo",
+			},
+			patch2: Patch{
+				Path: "bar",
+			},
+			expect: false,
+		},
+	}
+
+	for _, tc := range testcases {
+		if tc.expect != tc.patch1.Equals(tc.patch2) {
+			t.Fatalf("%s: unexpected result %v", tc.name, !tc.expect)
+		}
+	}
+}

api/types/patchjson6902.go

@@ -1,27 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package types
-
-// PatchJson6902 represents a json patch for an object
-// with format documented https://tools.ietf.org/html/rfc6902.
-type PatchJson6902 struct {
-	// PatchTarget refers to a Kubernetes object that the json patch will be
-	// applied to. It must refer to a Kubernetes resource under the
-	// purview of this kustomization. PatchTarget should use the
-	// raw name of the object (the name specified in its YAML,
-	// before addition of a namePrefix and a nameSuffix).
-	Target *PatchTarget `json:"target" yaml:"target"`
-
-	// relative file path for a json patch file inside a kustomization
-	Path string `json:"path,omitempty" yaml:"path,omitempty"`
-
-	// inline patch string
-	Patch string `json:"patch,omitempty" yaml:"patch,omitempty"`
-}
-
-// ToPatch converts a PatchJson6902 to its superset Patch.
-func (patch *PatchJson6902) ToPatch() Patch {
-	selector := patch.Target.ToSelector()
-	return Patch{Path: patch.Path, Patch: patch.Patch, Target: &selector}
-}

api/types/patchtarget.go

@@ -1,20 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package types
-
-import (
-	"sigs.k8s.io/kustomize/api/resid"
-)
-
-// PatchTarget represents the kubernetes object that the patch is applied to
-type PatchTarget struct {
-	resid.Gvk `json:",inline,omitempty" yaml:",inline,omitempty"`
-	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
-	Name      string `json:"name" yaml:"name"`
-}
-
-// ToSelector converts a PatchTarget to a Selector.
-func (target *PatchTarget) ToSelector() Selector {
-	return Selector{Name: target.Name, Namespace: target.Namespace, Gvk: target.Gvk}
-}

api/types/pluginrestrictions.go

@@ -53,4 +53,6 @@ type FnPluginLoadingOptions struct {
 	NetworkName string
 	// list of mounts
 	Mounts []string
+	// list of env variables to pass to fn
+	Env []string
 }

api/types/selector.go

@@ -4,6 +4,8 @@
 package types
 
 import (
+	"regexp"
+
 	"sigs.k8s.io/kustomize/api/resid"
 )
 
@@ -25,3 +27,89 @@ type Selector struct {
 	// It matches with the resource labels.
 	LabelSelector string `json:"labelSelector,omitempty" yaml:"labelSelector,omitempty"`
 }
+
+// SelectorRegex is a Selector with regex in GVK
+// Any resource that matches intersection of all conditions
+// is included in this set.
+type SelectorRegex struct {
+	selector       *Selector
+	groupRegex     *regexp.Regexp
+	versionRegex   *regexp.Regexp
+	kindRegex      *regexp.Regexp
+	nameRegex      *regexp.Regexp
+	namespaceRegex *regexp.Regexp
+}
+
+// NewSelectorRegex returns a pointer to a new SelectorRegex
+// which uses the same condition as s.
+func NewSelectorRegex(s *Selector) (*SelectorRegex, error) {
+	sr := new(SelectorRegex)
+	var err error
+	sr.selector = s
+	sr.groupRegex, err = regexp.Compile(anchorRegex(s.Gvk.Group))
+	if err != nil {
+		return nil, err
+	}
+	sr.versionRegex, err = regexp.Compile(anchorRegex(s.Gvk.Version))
+	if err != nil {
+		return nil, err
+	}
+	sr.kindRegex, err = regexp.Compile(anchorRegex(s.Gvk.Kind))
+	if err != nil {
+		return nil, err
+	}
+	sr.nameRegex, err = regexp.Compile(anchorRegex(s.Name))
+	if err != nil {
+		return nil, err
+	}
+	sr.namespaceRegex, err = regexp.Compile(anchorRegex(s.Namespace))
+	if err != nil {
+		return nil, err
+	}
+	return sr, nil
+}
+
+func anchorRegex(pattern string) string {
+	if pattern == "" {
+		return pattern
+	}
+	return "^(?:" + pattern + ")$"
+}
+
+// MatchGvk return true if gvk can be matched by s.
+func (s *SelectorRegex) MatchGvk(gvk resid.Gvk) bool {
+	if len(s.selector.Gvk.Group) > 0 {
+		if !s.groupRegex.MatchString(gvk.Group) {
+			return false
+		}
+	}
+	if len(s.selector.Gvk.Version) > 0 {
+		if !s.versionRegex.MatchString(gvk.Version) {
+			return false
+		}
+	}
+	if len(s.selector.Gvk.Kind) > 0 {
+		if !s.kindRegex.MatchString(gvk.Kind) {
+			return false
+		}
+	}
+	return true
+}
+
+// MatchName returns true if the name in selector is
+// empty or the n can be matches by the name in selector
+func (s *SelectorRegex) MatchName(n string) bool {
+	if s.selector.Name == "" {
+		return true
+	}
+	return s.nameRegex.MatchString(n)
+}
+
+// MatchNamespace returns true if the namespace in selector is
+// empty or the ns can be matches by the namespace in selector
+func (s *SelectorRegex) MatchNamespace(ns string) bool {
+	if s.selector.Namespace == "" {
+		return true
+	}
+	return s.namespaceRegex.MatchString(ns)
+}

api/types/selector_test.go

@@ -0,0 +1,216 @@
+package types_test
+
+import (
+	"testing"
+
+	"sigs.k8s.io/kustomize/api/resid"
+	. "sigs.k8s.io/kustomize/api/types"
+)
+
+func TestSelectorRegexMatchGvk(t *testing.T) {
+	testcases := []struct {
+		S        Selector
+		G        resid.Gvk
+		Expected bool
+	}{
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "group",
+					Version: "version",
+					Kind:    "kind",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "version",
+				Kind:    "kind",
+			},
+			Expected: true,
+		},
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "group",
+					Version: "",
+					Kind:    "",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "version",
+				Kind:    "kind",
+			},
+			Expected: true,
+		},
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "group",
+					Version: "version",
+					Kind:    "kind",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "version",
+				Kind:    "",
+			},
+			Expected: false,
+		},
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "group",
+					Version: "version",
+					Kind:    "kind",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "version",
+				Kind:    "kind2",
+			},
+			Expected: false,
+		},
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "g.*",
+					Version: "\\d+",
+					Kind:    ".{4}",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "123",
+				Kind:    "abcd",
+			},
+			Expected: true,
+		},
+		{
+			S: Selector{
+				Gvk: resid.Gvk{
+					Group:   "g.*",
+					Version: "\\d+",
+					Kind:    ".{4}",
+				},
+			},
+			G: resid.Gvk{
+				Group:   "group",
+				Version: "123",
+				Kind:    "abc",
+			},
+			Expected: false,
+		},
+	}
+
+	for _, tc := range testcases {
+		sr, err := NewSelectorRegex(&tc.S)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if sr.MatchGvk(tc.G) != tc.Expected {
+			t.Fatalf("unexpected result for selector gvk %s and gvk %s",
+				tc.S.Gvk.String(), tc.G.String())
+		}
+	}
+}
+
+func TestSelectorRegexMatchName(t *testing.T) {
+	testcases := []struct {
+		S        Selector
+		Name     string
+		Expected bool
+	}{
+		{
+			S: Selector{
+				Name:      "foo",
+				Namespace: "bar",
+			},
+			Name:     "foo",
+			Expected: true,
+		},
+		{
+			S: Selector{
+				Name:      "foo",
+				Namespace: "bar",
+			},
+			Name:     "bar",
+			Expected: false,
+		},
+		{
+			S: Selector{
+				Name: "f.*",
+			},
+			Name:     "foo",
+			Expected: true,
+		},
+		{
+			S: Selector{
+				Name: "b.*",
+			},
+			Name:     "foo",
+			Expected: false,
+		},
+	}
+	for _, tc := range testcases {
+		sr, err := NewSelectorRegex(&tc.S)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if sr.MatchName(tc.Name) != tc.Expected {
+			t.Fatalf("unexpected result for selector name %s and name %s",
+				tc.S.Name, tc.Name)
+		}
+	}
+}
+
+func TestSelectorRegexMatchNamespace(t *testing.T) {
+	testcases := []struct {
+		S         Selector
+		Namespace string
+		Expected  bool
+	}{
+		{
+			S: Selector{
+				Name:      "bar",
+				Namespace: "foo",
+			},
+			Namespace: "foo",
+			Expected:  true,
+		},
+		{
+			S: Selector{
+				Name:      "foo",
+				Namespace: "bar",
+			},
+			Namespace: "foo",
+			Expected:  false,
+		},
+		{
+			S: Selector{
+				Namespace: "f.*",
+			},
+			Namespace: "foo",
+			Expected:  true,
+		},
+		{
+			S: Selector{
+				Namespace: "b.*",
+			},
+			Namespace: "foo",
+			Expected:  false,
+		},
+	}
+	for _, tc := range testcases {
+		sr, err := NewSelectorRegex(&tc.S)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if sr.MatchNamespace(tc.Namespace) != tc.Expected {
+			t.Fatalf("unexpected result for selector namespace %s and namespace %s",
+				tc.S.Namespace, tc.Namespace)
+		}
+	}
+}

cmd/config/complete/complete.go

@@ -1,72 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package complete
-
-import (
-	"os"
-	"strings"
-
-	"github.com/posener/complete/v2"
-	"github.com/posener/complete/v2/predict"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"sigs.k8s.io/kustomize/cmd/config/internal/generateddocs/commands"
-	"sigs.k8s.io/kustomize/kyaml/errors"
-)
-
-// NewCommand returns a new install-completion command
-func NewCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:     "install-completion",
-		Short:   commands.CompletionShort,
-		Long:    commands.CompletionLong,
-		PreRunE: preRunE,
-		Run:     run,
-	}
-}
-
-func preRunE(cmd *cobra.Command, args []string) error {
-	// install by default
-	if os.Getenv("COMP_INSTALL") == "" {
-		if err := errors.Wrap(os.Setenv("COMP_INSTALL", "1")); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func run(cmd *cobra.Command, args []string) {
-	// find the root command
-	for cmd.Parent() != nil {
-		cmd = cmd.Parent()
-	}
-
-	// do completion
-	Complete(cmd).Complete("kustomize")
-}
-
-// Complete returns a completion command for a cobra command
-func Complete(cmd *cobra.Command) *complete.Command {
-	cc := &complete.Command{
-		Flags: map[string]complete.Predictor{},
-		Sub:   map[string]*complete.Command{},
-	}
-	if strings.Contains(cmd.Use, "DIR") {
-		// if usage contains directory, then use a file predictor
-		cc.Args = predict.Dirs("*")
-	}
-
-	// add completion for each subcommand
-	for i := range cmd.Commands() {
-		c := cmd.Commands()[i]
-		name := strings.Split(c.Use, " ")[0]
-		cc.Sub[name] = Complete(c)
-	}
-
-	// add completion for each flag
-	cmd.Flags().VisitAll(func(flag *pflag.Flag) {
-		cc.Flags[flag.Name] = predict.Nothing
-	})
-	return cc
-}

cmd/config/completion/completion.go

@@ -0,0 +1,33 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package completion
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+func NewCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:                   "completion [bash|zsh|fish|powershell]",
+		Short:                 "Generate shell completion script",
+		Long:                  "Generate shell completion.",
+		DisableFlagsInUseLine: true,
+		ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
+		Args:                  cobra.ExactValidArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			switch args[0] {
+			case "bash":
+				cmd.Root().GenBashCompletion(os.Stdout)
+			case "zsh":
+				cmd.Root().GenZshCompletion(os.Stdout)
+			case "fish":
+				cmd.Root().GenFishCompletion(os.Stdout, true)
+			case "powershell":
+				cmd.Root().GenPowerShellCompletion(os.Stdout)
+			}
+		},
+	}
+}

cmd/config/configcobra/cmds.go

@@ -10,6 +10,7 @@ import (
 	"sigs.k8s.io/kustomize/cmd/config/internal/commands"
 	"sigs.k8s.io/kustomize/cmd/config/internal/generateddocs/api"
 	"sigs.k8s.io/kustomize/cmd/config/internal/generateddocs/tutorials"
+	"sigs.k8s.io/kustomize/cmd/config/runner"
 )
 
 // Export commands publicly for composition
@@ -35,20 +36,19 @@ var (
 	Wrap               = commands.WrapCommand
 	XArgs              = commands.XArgsCommand
 
-	StackOnError = &commands.StackOnError
-	ExitOnError  = &commands.ExitOnError
+	StackOnError = &runner.StackOnError
+	ExitOnError  = &runner.ExitOnError
 )
 
-// AddCommands adds the cfg, fn and live commands to kustomize.
+// AddCommands adds the cfg and fn commands to kustomize.
 func AddCommands(root *cobra.Command, name string) *cobra.Command {
-	commands.ExitOnError = true
+	runner.ExitOnError = true
 
 	root.PersistentFlags().BoolVar(StackOnError, "stack-trace", false,
 		"print a stack-trace on error")
 
 	root.AddCommand(GetCfg(name))
 	root.AddCommand(GetFn(name))
-	root.AddCommand(GetLive(name))
 
 	root.AddCommand(&cobra.Command{
 		Use:   "docs-merge",

cmd/config/configcobra/live.go

@@ -1,89 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package configcobra
-
-import (
-	"flag"
-
-	"github.com/spf13/cobra"
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
-	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/kubectl/pkg/cmd/util"
-	"sigs.k8s.io/cli-utils/cmd/apply"
-	"sigs.k8s.io/cli-utils/cmd/destroy"
-	"sigs.k8s.io/cli-utils/cmd/diff"
-	"sigs.k8s.io/cli-utils/cmd/initcmd"
-	"sigs.k8s.io/cli-utils/cmd/preview"
-	"sigs.k8s.io/cli-utils/pkg/util/factory"
-)
-
-func GetLive(name string) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "live",
-		Short: "Commands for reading and writing resources to a cluster.",
-	}
-	ioStreams := genericclioptions.IOStreams{
-		In:     cmd.InOrStdin(),
-		Out:    cmd.OutOrStdout(),
-		ErrOut: cmd.ErrOrStderr(),
-	}
-
-	flags := cmd.PersistentFlags()
-	kubeConfigFlags := genericclioptions.NewConfigFlags(true).WithDeprecatedPasswordFlag()
-	kubeConfigFlags.AddFlags(flags)
-	userAgentKubeConfigFlags := &UserAgentKubeConfigFlags{
-		Delegate:  kubeConfigFlags,
-		UserAgent: "kustomize",
-	}
-	matchVersionKubeConfigFlags := util.NewMatchVersionFlags(
-		&factory.CachingRESTClientGetter{
-			Delegate: userAgentKubeConfigFlags,
-		},
-	)
-	matchVersionKubeConfigFlags.AddFlags(cmd.PersistentFlags())
-	cmd.PersistentFlags().AddGoFlagSet(flag.CommandLine)
-	f := util.NewFactory(matchVersionKubeConfigFlags)
-
-	applyCmd := apply.ApplyCommand(f, ioStreams)
-	_ = applyCmd.Flags().MarkHidden("no-prune")
-
-	cmd.AddCommand(
-		applyCmd,
-		initcmd.NewCmdInit(ioStreams),
-		preview.GetPreviewRunner(f, ioStreams).Command,
-		diff.NewCmdDiff(f, ioStreams),
-		destroy.GetDestroyRunner(f, ioStreams).Command)
-	return cmd
-}
-
-type UserAgentKubeConfigFlags struct {
-	Delegate  genericclioptions.RESTClientGetter
-	UserAgent string
-}
-
-func (u *UserAgentKubeConfigFlags) ToRESTConfig() (*rest.Config, error) {
-	clientConfig, err := u.Delegate.ToRESTConfig()
-	if err != nil {
-		return nil, err
-	}
-	if u.UserAgent != "" {
-		clientConfig.UserAgent = u.UserAgent
-	}
-	return clientConfig, nil
-}
-
-func (u *UserAgentKubeConfigFlags) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
-	return u.Delegate.ToDiscoveryClient()
-}
-
-func (u *UserAgentKubeConfigFlags) ToRESTMapper() (meta.RESTMapper, error) {
-	return u.Delegate.ToRESTMapper()
-}
-
-func (u *UserAgentKubeConfigFlags) ToRawKubeConfigLoader() clientcmd.ClientConfig {
-	return u.Delegate.ToRawKubeConfigLoader()
-}