| // Copyright (c) The OpenTofu Authors | |
| // SPDX-License-Identifier: MPL-2.0 | |
| // Copyright (c) 2023 HashiCorp, Inc. | |
| // SPDX-License-Identifier: MPL-2.0 | |
| package funcs | |
| import ( | |
| "regexp" | |
| "strings" | |
| "github.com/hashicorp/hcl/v2" | |
| "github.com/hashicorp/hcl/v2/hclsyntax" | |
| "github.com/zclconf/go-cty/cty" | |
| "github.com/zclconf/go-cty/cty/function" | |
| ) | |
| // StartsWithFunc constructs a function that checks if a string starts with | |
| // a specific prefix using strings.HasPrefix | |
| var StartsWithFunc = function.New(&function.Spec{ | |
| Params: []function.Parameter{ | |
| { | |
| Name: "str", | |
| Type: cty.String, | |
| AllowUnknown: true, | |
| }, | |
| { | |
| Name: "prefix", | |
| Type: cty.String, | |
| }, | |
| }, | |
| Type: function.StaticReturnType(cty.Bool), | |
| RefineResult: refineNotNull, | |
| Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) { | |
| prefix := args[1].AsString() | |
| if !args[0].IsKnown() { | |
| // If the unknown value has a known prefix then we might be | |
| // able to still produce a known result. | |
| if prefix == "" { | |
| // The empty string is a prefix of any string. | |
| return cty.True, nil | |
| } | |
| if knownPrefix := args[0].Range().StringPrefix(); knownPrefix != "" { | |
| if strings.HasPrefix(knownPrefix, prefix) { | |
| return cty.True, nil | |
| } | |
| if len(knownPrefix) >= len(prefix) { | |
| // If the prefix we're testing is no longer than the known | |
| // prefix and it didn't match then the full string with | |
| // that same prefix can't match either. | |
| return cty.False, nil | |
| } | |
| } | |
| return cty.UnknownVal(cty.Bool), nil | |
| } | |
| str := args[0].AsString() | |
| if strings.HasPrefix(str, prefix) { | |
| return cty.True, nil | |
| } | |
| return cty.False, nil | |
| }, | |
| }) | |
| // EndsWithFunc constructs a function that checks if a string ends with | |
| // a specific suffix using strings.HasSuffix | |
| var EndsWithFunc = function.New(&function.Spec{ | |
| Params: []function.Parameter{ | |
| { | |
| Name: "str", | |
| Type: cty.String, | |
| }, | |
| { | |
| Name: "suffix", | |
| Type: cty.String, | |
| }, | |
| }, | |
| Type: function.StaticReturnType(cty.Bool), | |
| RefineResult: refineNotNull, | |
| Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) { | |
| str := args[0].AsString() | |
| suffix := args[1].AsString() | |
| if strings.HasSuffix(str, suffix) { | |
| return cty.True, nil | |
| } | |
| return cty.False, nil | |
| }, | |
| }) | |
| // ReplaceFunc constructs a function that searches a given string for another | |
| // given substring, and replaces each occurrence with a given replacement string. | |
| var ReplaceFunc = function.New(&function.Spec{ | |
| Params: []function.Parameter{ | |
| { | |
| Name: "str", | |
| Type: cty.String, | |
| }, | |
| { | |
| Name: "substr", | |
| Type: cty.String, | |
| }, | |
| { | |
| Name: "replace", | |
| Type: cty.String, | |
| }, | |
| }, | |
| Type: function.StaticReturnType(cty.String), | |
| RefineResult: refineNotNull, | |
| Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) { | |
| str := args[0].AsString() | |
| substr := args[1].AsString() | |
| replace := args[2].AsString() | |
| // We search/replace using a regexp if the string is surrounded | |
| // in forward slashes. | |
| if len(substr) > 1 && substr[0] == '/' && substr[len(substr)-1] == '/' { | |
| re, err := regexp.Compile(substr[1 : len(substr)-1]) | |
| if err != nil { | |
| return cty.UnknownVal(cty.String), err | |
| } | |
| return cty.StringVal(re.ReplaceAllString(str, replace)), nil | |
| } | |
| return cty.StringVal(strings.ReplaceAll(str, substr, replace)), nil | |
| }, | |
| }) | |
| // StrContainsFunc searches a given string for another given substring, | |
| // if found the function returns true, otherwise returns false. | |
| var StrContainsFunc = function.New(&function.Spec{ | |
| Params: []function.Parameter{ | |
| { | |
| Name: "str", | |
| Type: cty.String, | |
| }, | |
| { | |
| Name: "substr", | |
| Type: cty.String, | |
| }, | |
| }, | |
| Type: function.StaticReturnType(cty.Bool), | |
| Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) { | |
| str := args[0].AsString() | |
| substr := args[1].AsString() | |
| if strings.Contains(str, substr) { | |
| return cty.True, nil | |
| } | |
| return cty.False, nil | |
| }, | |
| }) | |
| // Replace searches a given string for another given substring, | |
| // and replaces all occurrences with a given replacement string. | |
| func Replace(str, substr, replace cty.Value) (cty.Value, error) { | |
| return ReplaceFunc.Call([]cty.Value{str, substr, replace}) | |
| } | |
| func StrContains(str, substr cty.Value) (cty.Value, error) { | |
| return StrContainsFunc.Call([]cty.Value{str, substr}) | |
| } | |
| // This constant provides a placeholder value for filename indicating | |
| // that no file is needed for templatestring. | |
| const ( | |
| templateStringFilename = "NoFileNeeded" | |
| ) | |
| // MakeTemplateStringFunc constructs a function that takes a string and | |
| // an arbitrary object of named values and attempts to render that string | |
| // as a template using HCL template syntax. | |
| func MakeTemplateStringFunc(content string, funcsCb func() map[string]function.Function) function.Function { | |
| params := []function.Parameter{ | |
| { | |
| Name: "data", | |
| Type: cty.String, | |
| AllowMarked: true, | |
| }, | |
| { | |
| Name: "vars", | |
| Type: cty.DynamicPseudoType, | |
| AllowMarked: true, | |
| }, | |
| } | |
| loadTmpl := func(content string, marks cty.ValueMarks) (hcl.Expression, error) { | |
| expr, diags := hclsyntax.ParseTemplate([]byte(content), templateStringFilename, hcl.Pos{Line: 1, Column: 1}) | |
| if diags.HasErrors() { | |
| return nil, diags | |
| } | |
| return expr, nil | |
| } | |
| return function.New(&function.Spec{ | |
| Params: params, | |
| Type: func(args []cty.Value) (cty.Type, error) { | |
| if !args[0].IsKnown() || !args[1].IsKnown() { | |
| return cty.DynamicPseudoType, nil | |
| } | |
| // We'll render our template now to see what result type it produces. | |
| // A template consisting only of a single interpolation can potentially | |
| // return any type. | |
| dataArg, dataMarks := args[0].Unmark() | |
| varsArg, _ := args[1].Unmark() | |
| expr, err := loadTmpl(dataArg.AsString(), dataMarks) | |
| if err != nil { | |
| return cty.DynamicPseudoType, err | |
| } | |
| // This is safe even if args[1] contains unknowns because the HCL | |
| // template renderer itself knows how to short-circuit those. | |
| val, err := renderTemplate(expr, varsArg, funcsCb()) | |
| return val.Type(), err | |
| }, | |
| Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) { | |
| dataArg, dataMarks := args[0].Unmark() | |
| varsArg, varsMarks := args[1].Unmark() | |
| expr, err := loadTmpl(dataArg.AsString(), dataMarks) | |
| if err != nil { | |
| return cty.DynamicVal, err | |
| } | |
| result, err := renderTemplate(expr, varsArg, funcsCb()) | |
| return result.WithMarks(dataMarks, varsMarks), err | |
| }, | |
| }) | |
| } |