func processTemplates()

in cmd/hub/lifecycle/template.go [60:164]
96 lines of code
30 McCabe index (conditional complexity)

func processTemplates(component *manifest.ComponentRef, templateSetup *manifest.TemplateSetup,
	params parameters.LockedParameters, outputs parameters.CapturedOutputs,
	dir string) []error {

	componentName := manifest.ComponentQualifiedNameFromRef(component)
	kv := parameters.ParametersKV(params)
	templateSetup, err := expandParametersInTemplateSetup(templateSetup, kv)
	if err != nil {
		return []error{err}
	}
	err = checkTemplateSetupKind(templateSetup)
	if err != nil {
		return []error{err}
	}
	templates := scanTemplates(componentName, dir, templateSetup)

	if config.Verbose {
		if len(templates) > 0 {
			log.Print("Component templates:")
			printTemplates(templates)
		} else if len(templateSetup.Files) > 0 || len(templateSetup.Directories) > 0 || len(templateSetup.Extra) > 0 {
			log.Printf("No templates for component `%s`", componentName)
		}
	}

	if len(templates) == 0 {
		return nil
	}

	filenames := make([]string, 0, len(templates))
	hasMustache := false
	hasGo := false
	for _, template := range templates {
		filenames = append(filenames, template.Filename)
		if !hasMustache && template.Kind == trueMustacheKind {
			hasMustache = true
		}
		if !hasGo && template.Kind == goKind {
			hasGo = true
		}
	}
	cannot := checkStat(filenames)
	if len(cannot) > 0 {
		diag := make([]string, 0, len(cannot))
		for _, e := range cannot {
			diag = append(diag, fmt.Sprintf("\t`%s`: %v", e.Filename, e.Error))
		}
		return []error{fmt.Errorf("Unable to open `%s` component template input(s):\n%s", componentName, strings.Join(diag, "\n"))}
	}

	// during lifecycle operation `outputs` is nil - only parameters are available in templates
	// outputs are for `hub render`
	if outputs != nil {
		var depends []string
		if hasMustache || hasGo {
			depends = component.Depends
		}
		kv = parameters.ParametersAndOutputsKVWithDepends(params, outputs, depends)
	}
	if config.Trace {
		log.Printf("Template binding:\n%v", kv)
	}
	var mustacheKV map[string]interface{}
	if hasMustache {
		mustacheKV = mustacheCompatibleBindings(kv)
		if config.Trace {
			log.Printf("Mustache template binding:\n%v", mustacheKV)
		}
	}
	var goKV map[string]interface{}
	if hasGo {
		goKV = goTemplateBindings(kv)
		if config.Trace {
			log.Printf("Go template binding:\n%v", goKV)
		}
	}

	processor := func(content, filename, kind string) (string, []error) {
		var outContent string
		var err error
		var errs []error
		switch kind {
		case "", curlyKind:
			outContent, errs = processReplacement(content, filename, componentName, component.Depends, kv,
				curlyReplacement, stripCurly)
		case mustacheKind:
			outContent, errs = processReplacement(content, filename, componentName, component.Depends, kv,
				mustacheReplacement, stripMustache)
		case trueMustacheKind:
			outContent, err = processMustache(content, filename, componentName, mustacheKV)
		case goKind:
			outContent, err = processGo(content, filename, componentName, goKV)
		}
		if err != nil {
			errs = append(errs, err)
		}
		return outContent, errs
	}

	errs := make([]error, 0)
	for _, template := range templates {
		errs = append(errs, processTemplate(template.Filename, template.Kind, componentName, processor)...)
	}
	return errs
}