Implement localize methods on ReplacementTransformer

Move field processing into Transform() for MapFiles()

plugin/builtin/replacementtransformer/ReplacementTransformer.go

@@ -11,36 +11,54 @@ import (
 	"sigs.k8s.io/kustomize/api/filters/replacement"
 	"sigs.k8s.io/kustomize/api/resmap"
 	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/kyaml/errors"
 	"sigs.k8s.io/yaml"
 )
 
 // Replace values in targets with values from a source
 type plugin struct {
-	ReplacementList []types.ReplacementField `json:"replacements,omitempty" yaml:"replacements,omitempty"`
-	Replacements    []types.Replacement      `json:"omitempty" yaml:"omitempty"`
+	h *resmap.PluginHelpers
+
+	types.ObjectMeta `json:"metadata,omitempty" yaml:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+	ReplacementList  []types.ReplacementField `json:"replacements,omitempty" yaml:"replacements,omitempty"`
 }
 
 //noinspection GoUnusedGlobalVariable
 var KustomizePlugin plugin
 
-func (p *plugin) Config(
-	h *resmap.PluginHelpers, c []byte) (err error) {
+func (p *plugin) Config(h *resmap.PluginHelpers, c []byte) error {
 	p.ReplacementList = []types.ReplacementField{}
-	if err := yaml.Unmarshal(c, p); err != nil {
-		return err
+	p.h = h // TODO: deep copy
+	return errors.WrapPrefixf(yaml.Unmarshal(c, p), "unable to initialize replacement transformer")
+}
+
+func (p *plugin) MapFiles(m func(string) (string, error)) error {
+	for i := range p.ReplacementList {
+		if p.ReplacementList[i].Path != "" {
+			mappedPath, err := m(p.ReplacementList[i].Path)
+			if err != nil {
+				return errors.WrapPrefixf(err, "unable to map replacement path")
+			}
+			p.ReplacementList[i].Path = mappedPath
+		}
 	}
+	return nil
+}
 
+func (p *plugin) Transform(m resmap.ResMap) error {
+	// configure close to transform to avoid work needed to maintain state
+	var replacements []types.Replacement
 	for _, r := range p.ReplacementList {
 		if r.Path != "" && (r.Source != nil || len(r.Targets) != 0) {
 			return fmt.Errorf("cannot specify both path and inline replacement")
 		}
 		if r.Path != "" {
 			// load the replacement from the path
-			content, err := h.Loader().Load(r.Path)
+			content, err := p.h.Loader().Load(r.Path)
 			if err != nil {
 				return err
 			}
-			// find if the path contains a a list of replacements or a single replacement
+			// find if the path contains a list of replacements or a single replacement
 			var replacement interface{}
 			err = yaml.Unmarshal(content, &replacement)
 			if err != nil {
@@ -49,30 +67,36 @@ func (p *plugin) Config(
 			items := reflect.ValueOf(replacement)
 			switch items.Kind() {
 			case reflect.Slice:
-				repl := []types.Replacement{}
-				if err := yaml.Unmarshal(content, &repl); err != nil {
+				repl := make([]types.Replacement, 0)
+				if err = yaml.Unmarshal(content, &repl); err != nil {
 					return err
 				}
-				p.Replacements = append(p.Replacements, repl...)
+				replacements = append(replacements, repl...)
 			case reflect.Map:
 				repl := types.Replacement{}
-				if err := yaml.Unmarshal(content, &repl); err != nil {
+				if err = yaml.Unmarshal(content, &repl); err != nil {
 					return err
 				}
-				p.Replacements = append(p.Replacements, repl)
+				replacements = append(replacements, repl)
 			default:
 				return fmt.Errorf("unsupported replacement type encountered within replacement path: %v", items.Kind())
 			}
 		} else {
 			// replacement information is already loaded
-			p.Replacements = append(p.Replacements, r.Replacement)
+			replacements = append(replacements, r.Replacement)
 		}
 	}
-	return nil
-}
-
-func (p *plugin) Transform(m resmap.ResMap) (err error) {
 	return m.ApplyFilter(replacement.Filter{
-		Replacements: p.Replacements,
+		Replacements: replacements,
 	})
 }
+
+func (p *plugin) YAML() ([]byte, error) {
+	b, err := yaml.Marshal(p)
+	if err != nil {
+		return nil, errors.WrapPrefixf(err, "unable to serialize replacements")
+	}
+	return append([]byte(`apiVersion: builtin
+kind: ReplacementTransformer
+`), b...), nil
+}