Function RenderTemplatesInString

utils/utils.go:1449–1501

RenderTemplatesInString finds all template placeholders (e.g., {{.name}} or {{string .name}}) in a string, executes them with the provided data, and replaces them with the result. It is robust against strings that contain non-template curly braces by using a strict regex.

(logger *zap.Logger, input string, templateData map[string]interface{})

// executes them with the provided data, and replaces them with the result.
// It is robust against strings that contain non-template curly braces by using a strict regex.
func RenderTemplatesInString(logger *zap.Logger, input string, templateData map[string]interface{}) (string, error) {
	// This regex is specifically designed to match valid Keploy templates:
	// - It must start with {{ and optional whitespace.
	// - It can optionally have a function call ("string", "int", "float") followed by whitespace.
	// - It MUST contain a dot (.) to indicate a field access.
	// - It non-greedily matches characters until the closing braces.
	// This prevents it from matching invalid syntax like {{u^2}}.
	re := regexp.MustCompile(`\{\{\s*(?:string\s+|int\s+|float\s+)?\.[^{}]*?\}\}`)

	funcMap := template.FuncMap{
		"int":    ToInt,
		"string": ToString,
		"float":  ToFloat,
	}

	var firstErr error

	// Check if the entire input string is a single template placeholder.
	// This is more efficient than using MatchString and FindString separately.
	matchIndexes := re.FindStringIndex(input)
	isExactPlaceholderMatch := matchIndexes != nil && matchIndexes[0] == 0 && matchIndexes[1] == len(input)

	result := re.ReplaceAllStringFunc(input, func(match string) string {
		// Only parse and execute the matched placeholder, not the entire string.
		tmpl, err := template.New("sub").Funcs(funcMap).Parse(match)
		if err != nil {

			logger.Debug("failed to parse a valid-looking template placeholder", zap.String("placeholder", match), zap.Error(err))
			return match
		}

		var output bytes.Buffer
		err = tmpl.Execute(&output, templateData)
		if err != nil {
			if firstErr == nil {
				firstErr = fmt.Errorf("failed to execute template placeholder '%s': %v", match, err)
			}
			return match
		}

		if isExactPlaceholderMatch {
			return output.String()
		}

		// Ensure the placeholder result is safe to embed inside JSON strings by
		// escaping control characters like newlines, quotes, and backslashes.
		// This prevents errors such as `invalid character '\n' in string literal`
		// when we later json.Unmarshal the rendered testcase.
		return jsonEscapeString(logger, output.String())
	})

	return result, firstErr
}

// jsonEscapeString returns a JSON-safe representation of s suitable for
// embedding directly inside a JSON string literal. It escapes characters