Bump sigs.k8s.io/controller-tools from 0.6.2 to 0.11.1 (#5432)

vendor/sigs.k8s.io/controller-tools/pkg/genall/genall.go

@@ -17,13 +17,14 @@ limitations under the License.
 package genall
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 
 	"golang.org/x/tools/go/packages"
-	"sigs.k8s.io/yaml"
+	rawyaml "gopkg.in/yaml.v2"
 
 	"sigs.k8s.io/controller-tools/pkg/loader"
 	"sigs.k8s.io/controller-tools/pkg/markers"
@@ -100,6 +101,8 @@ type Runtime struct {
 	GenerationContext
 	// OutputRules defines how to output artifacts for each Generator.
 	OutputRules OutputRules
+	// ErrorWriter defines where to write error messages.
+	ErrorWriter io.Writer
 }
 
 // GenerationContext defines the common information needed for each Generator
@@ -118,10 +121,22 @@ type GenerationContext struct {
 	InputRule
 }
 
+// WriteYAMLOptions implements the Options Pattern for WriteYAML.
+type WriteYAMLOptions struct {
+	transform func(obj map[string]interface{}) error
+}
+
+// WithTransform applies a transformation to objects just before writing them.
+func WithTransform(transform func(obj map[string]interface{}) error) *WriteYAMLOptions {
+	return &WriteYAMLOptions{
+		transform: transform,
+	}
+}
+
 // WriteYAML writes the given objects out, serialized as YAML, using the
 // context's OutputRule.  Objects are written as separate documents, separated
 // from each other by `---` (as per the YAML spec).
-func (g GenerationContext) WriteYAML(itemPath string, objs ...interface{}) error {
+func (g GenerationContext) WriteYAML(itemPath string, objs []interface{}, options ...*WriteYAMLOptions) error {
 	out, err := g.Open(nil, itemPath)
 	if err != nil {
 		return err
@@ -129,11 +144,11 @@ func (g GenerationContext) WriteYAML(itemPath string, objs ...interface{}) error
 	defer out.Close()
 
 	for _, obj := range objs {
-		yamlContent, err := yaml.Marshal(obj)
+		yamlContent, err := yamlMarshal(obj, options...)
 		if err != nil {
 			return err
 		}
-		n, err := out.Write(append([]byte("\n---\n"), yamlContent...))
+		n, err := out.Write(append([]byte("---\n"), yamlContent...))
 		if err != nil {
 			return err
 		}
@@ -145,6 +160,41 @@ func (g GenerationContext) WriteYAML(itemPath string, objs ...interface{}) error
 	return nil
 }
 
+// yamlMarshal is based on sigs.k8s.io/yaml.Marshal, but allows for transforming the final data before writing.
+func yamlMarshal(o interface{}, options ...*WriteYAMLOptions) ([]byte, error) {
+	j, err := json.Marshal(o)
+	if err != nil {
+		return nil, fmt.Errorf("error marshaling into JSON: %v", err)
+	}
+
+	return yamlJSONToYAMLWithFilter(j, options...)
+}
+
+// yamlJSONToYAMLWithFilter is based on sigs.k8s.io/yaml.JSONToYAML, but allows for transforming the final data before writing.
+func yamlJSONToYAMLWithFilter(j []byte, options ...*WriteYAMLOptions) ([]byte, error) {
+	// Convert the JSON to an object.
+	var jsonObj map[string]interface{}
+	// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
+	// Go JSON library doesn't try to pick the right number type (int, float,
+	// etc.) when unmarshalling to interface{}, it just picks float64
+	// universally. go-yaml does go through the effort of picking the right
+	// number type, so we can preserve number type throughout this process.
+	if err := rawyaml.Unmarshal(j, &jsonObj); err != nil {
+		return nil, err
+	}
+
+	for _, option := range options {
+		if option.transform != nil {
+			if err := option.transform(jsonObj); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	// Marshal this object into YAML.
+	return rawyaml.Marshal(jsonObj)
+}
+
 // ReadFile reads the given boilerplate artifact using the context's InputRule.
 func (g GenerationContext) ReadFile(path string) ([]byte, error) {
 	file, err := g.OpenForRead(path)
@@ -188,8 +238,12 @@ func (g Generators) ForRoots(rootPaths ...string) (*Runtime, error) {
 func (r *Runtime) Run() bool {
 	// TODO(directxman12): we could make this parallel,
 	// but we'd need to ensure all underlying machinery is threadsafe
+
+	if r.ErrorWriter == nil {
+		r.ErrorWriter = os.Stderr
+	}
 	if len(r.Generators) == 0 {
-		fmt.Fprintln(os.Stderr, "no generators to run")
+		fmt.Fprintln(r.ErrorWriter, "no generators to run")
 		return true
 	}
 
@@ -205,7 +259,7 @@ func (r *Runtime) Run() bool {
 		}
 
 		if err := (*gen).Generate(&ctx); err != nil {
-			fmt.Fprintln(os.Stderr, err)
+			fmt.Fprintln(r.ErrorWriter, err)
 			hadErrs = true
 		}
 	}