func PatchTemplate()

in pkg/build/patchbuild.go [36:85]
42 lines of code
9 McCabe index (conditional complexity)

func PatchTemplate(ptb *bundle.PatchTemplateBuilder, opts options.JSONOptions) (*bundle.PatchTemplate, error) {
	name := ptb.GetName()
	if ptb.Template == "" {
		return nil, fmt.Errorf("cannot build PatchTemplate from PatchTemplateBuilder %q: it has an empty template", name)
	}

	tmplFuncs := make(map[string]interface{})
	useSafeYAMLTemplater := internal.HasSafeYAMLAnnotation(ptb.ObjectMeta)
	tmpl, err := internal.NewTemplater("temporary-patch-template-builder", ptb.Template, tmplFuncs, useSafeYAMLTemplater)
	if err != nil {
		return nil, fmt.Errorf("cannot build PatchTemplate from PatchTemplateBuilder %q: error parsing template: %v", name, err)
	}

	if opts == nil {
		opts = make(options.JSONOptions)
	}

	if ptb.BuildSchema != nil {
		opts, err = openapi.ApplyDefaults(opts, ptb.BuildSchema)
		if err != nil {
			return nil, err
		}
	}

	// This is a hack to allow us to pass through runtime templates variables
	// It is only one level-deep. TODO(jbelamaric): fix it to support nested schema
	if ptb.TargetSchema != nil && ptb.TargetSchema.Properties != nil {
		addParamDefaults("", ptb.TargetSchema.Properties, opts)
	}

	tmpl = tmpl.Option("missingkey=error")
	var buf bytes.Buffer
	err = tmpl.Execute(&buf, opts)
	if err != nil {
		return nil, fmt.Errorf("cannot build PatchTemplate from PatchTemplateBuilder %q: error executing template: %v", name, err)
	}

	pt := &bundle.PatchTemplate{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "bundle.gke.io/v1alpha1",
			Kind:       "PatchTemplate",
		},
		PatchType:     ptb.PatchType,
		ObjectMeta:    *ptb.ObjectMeta.DeepCopy(),
		OptionsSchema: ptb.TargetSchema.DeepCopy(),
		Selector:      ptb.Selector.DeepCopy(),
		Template:      buf.String(),
	}
	return pt, nil
}