func mergeParameters()

in cmd/hub/compose/elaborate.go [662:748]
75 lines of code
23 McCabe index (conditional complexity)

func mergeParameters(parametersAssorti [][]manifest.Parameter,
	overrides map[string]string,
	wellKnown map[string]manifest.Parameter,
	allComponentsNames []string, nComponents int,
	isApplication bool) []manifest.Parameter {

	kv := make(map[string]manifest.Parameter)
	for docIndex, parameters := range parametersAssorti {
		isComponentManifest := docIndex < nComponents
		for _, parameter := range parameters {
			parameter = enrichParameter(parameter, wellKnown)
			parameter = updateKindIfFrom(parameter, isComponentManifest)

			if isComponentManifest {
				if parameter.Kind == "link" {
					util.Warn("Parameter `%s` specify `kind: link` on hub-component.yaml level - this is not supported",
						parameter.QName())
				}
				if parameter.Kind != "user" && util.Empty(parameter.Value) && !util.Empty(parameter.Default) {
					util.Warn("Parameter `%s` specify `default:` on hub-component.yaml level - use `value:` instead",
						parameter.QName())
				}
				// parameters from Stack Manifest and Parameters files are a special treat -
				// they always go to the top level in elaborated
				// component parameter is propagated to Stack Manifest only for kind == user
				if parameter.Kind != "user" {
					continue
				}
			}

			// below are either hub.yaml / params.yaml top-level parameters or
			// kind == user parameters from hub-component.yaml

			// TODO global env var support is suspended, decide to resume or remove
			if parameter.Env != "" { //  && !util.Contains(globalEnvVarsAllowed, parameter.Env) {
				if !isComponentManifest {
					if !isApplication {
						util.WarnOnce("Parameter `%s` specify `env: %s` on hub.yaml / params.yaml level",
							parameter.QName(), parameter.Env)
					}
				} else {
					if config.Trace {
						log.Printf("User-level parameter `%s` specify `env: %s` on hub-component.yaml level - not propagated to global env",
							parameter.QName(), parameter.Env)
					}
				}
				parameter.Env = ""
			}

			if parameter.Component == "" {
				qNames := make([]string, 0, 1+len(allComponentsNames))
				qNames = append(qNames, parameter.Name)
				for _, componentName := range allComponentsNames {
					qNames = append(qNames, manifest.ParameterQualifiedName(parameter.Name, componentName))
				}
				for i, qName := range qNames {
					p, exist := kv[qName]
					if !exist {
						if i == 0 { // plain parameter name
							kv[qName] = parameter
						}
					} else {
						if i != 0 {
							currValue := util.String(p.Value)
							newValue := util.String(parameter.Value)
							if newValue != "" && currValue != "" && newValue != currValue {
								util.Warn("Parameter `%s` value `%s` overwritten by a less specific parameter `%s` value `%s`",
									qName, currValue, parameter.QName(), newValue)
							}
						}
						kv[qName] = mergeParameter(p, parameter, overrides, false)
					}
				}
			} else {
				qName := parameter.QName()
				p, exist := kv[qName]
				if !exist {
					kv[qName] = parameter
				} else {
					kv[qName] = mergeParameter(p, parameter, overrides, false)
				}
			}
		}
	}

	return sortedParameters(kv)
}