Method OutputSub

cft/pkg/outputs.go:227–282

OutputSub checks a Sub to see if it refers to a module Output. A Sub string can refer to an output scalar value. The reference needs to be like a GetAtt. For example, !Sub ${A.B} refers to module A, output B.

(outputName string, outputVal any, n *yaml.Node)

// The reference needs to be like a GetAtt.
// For example, !Sub ${A.B} refers to module A, output B.
func (module *Module) OutputSub(outputName string, outputVal any, n *yaml.Node) error {
	s := n.Content[1].Value
	words, err := parse.ParseSub(s, true)
	if err != nil {
		return err
	}
	sub := ""
	for _, word := range words {
		switch word.T {
		case parse.STR:
			sub += word.W
		case parse.AWS:
			sub += "${AWS::" + word.W + "}"
		case parse.REF:
			sub += "${" + word.W + "}"
		case parse.GETATT:
			outputValue, err := module.CheckOutputGetAtt(word.W, outputName, outputVal)
			if err != nil {
				return err
			}
			if outputValue == nil {
				sub += "${" + word.W + "}"
			} else {
				if outputValue.Kind == yaml.MappingNode {
					// Prepend the module name
					v := outputValue.Content[1]
					switch outputValue.Content[0].Value {
					case string(cft.Sub):
						sub += "${" + v.Value + "}"
					case string(cft.GetAtt):
						ss := node.SequenceToStrings(v)
						joined := strings.Join(ss, ".")
						sub += "${" + joined + "}"
					case string(cft.Ref):
						sub += "${" + v.Value + "}"
					}
				} else if outputValue.Kind == yaml.ScalarNode {
					sub += outputValue.Value
				}
			}
		}
	}

	var subNode *yaml.Node
	if parse.IsSubNeeded(sub) {
		subNode = node.MakeMapping()
		subNode.Content = append(subNode.Content, node.MakeScalar(string(cft.Sub)))
		subNode.Content = append(subNode.Content, node.MakeScalar(sub))
	} else {
		subNode = node.MakeScalar(sub)
	}
	if sub != s {
		*n = *subNode
	}
	return nil
}

// After processing normal outputs, go back and look for array references