Documentation ¶
Overview ¶
Package tokens provides an easy way to create common hclwrite tokens (such as new line, comma, equal sign, ident)
It also provides an easy way to encapsulate hclwrite tokens into a cty.Value and a function (`Generate()`) to manage those type of value
Index ¶
- Constants
- func ContainsCapsule(valPtr *cty.Value) bool
- func FromValue(v cty.Value) hclwrite.Tokens
- func Generate(valuePtr *cty.Value) hclwrite.Tokens
- func GenerateFromIterable(elements []hclwrite.Tokens, toType cty.Type) hclwrite.Tokens
- func IsCapsuleType(t cty.Type) bool
- func MergeIterableAndGenerate(collection cty.Value, newElements []hclwrite.Tokens) hclwrite.Tokens
- func NewCommaToken() *hclwrite.Token
- func NewCommaTokens() hclwrite.Tokens
- func NewEqualToken() *hclwrite.Token
- func NewEqualTokens() hclwrite.Tokens
- func NewIdentListValue(list []string) *cty.Value
- func NewIdentToken(b []byte) *hclwrite.Token
- func NewIdentTokens(s string) hclwrite.Tokens
- func NewIdentValue(s string) *cty.Value
- func NewLineToken() *hclwrite.Token
- func NewLineTokens() hclwrite.Tokens
- func SplitIterable(collection cty.Value) (hclwrite.Tokens, hclwrite.Tokens, hclwrite.Tokens)
- func ToValue(tokens hclwrite.Tokens) cty.Value
Examples ¶
Constants ¶
const HclwriteTokensCtyTypeName = "cty.CapsuleVal(hclwrite.Tokens)"
HclwriteTokensCtyTypeName is the friendly cty name for the capsule encapsulating `hclwrite.Tokens`.
Variables ¶
This section is empty.
Functions ¶
func ContainsCapsule ¶
ContainsCapsule will deep check if provided value contains a special capsule encapsulating `hclwrite.Tokens` (and therefore requires special process to de-encapsulate it).
func FromValue ¶
FromValue takes a `cty.Value` and extract the `hclwrite.Tokens` from it.
It panics if the provided value is not a special `cty.Value` capsule.
func Generate ¶
Generate converts a `cty.Value` to `hclwrite.Tokens`
It takes care of special `cty.Value` capsule encapsulating `hclwrite.Tokens`.
Example ¶
package main import ( "fmt" "github.com/zclconf/go-cty/cty" "github.com/zclconf/go-cty/cty/gocty" "github.com/yoanm/go-tfsig/tokens" ) func main() { listOfCapsule, err := gocty.ToCtyValue( []cty.Value{ *tokens.NewIdentValue("value1"), *tokens.NewIdentValue("value2"), }, cty.List(cty.DynamicPseudoType), ) if err != nil { panic(err) } setOfCapsule, err := gocty.ToCtyValue( []cty.Value{ *tokens.NewIdentValue("value1"), *tokens.NewIdentValue("value2"), }, cty.Set(cty.DynamicPseudoType), ) if err != nil { panic(err) } objectWithCapsule, err := gocty.ToCtyValue( map[string]cty.Value{ "A": *tokens.NewIdentValue("A_value"), "B": cty.StringVal("B_value"), }, cty.Object( map[string]cty.Type{ "A": cty.DynamicPseudoType, "B": cty.String, }, ), ) if err != nil { panic(err) } mapOfCapsule, err := gocty.ToCtyValue( map[string]cty.Value{ "A": *tokens.NewIdentValue("A_value"), "B": *tokens.NewIdentValue("B_value"), }, cty.Map(cty.DynamicPseudoType), ) if err != nil { panic(err) } tupleWithCapsule, err := gocty.ToCtyValue( []cty.Value{ cty.StringVal("A_value"), *tokens.NewIdentValue("B_value"), cty.NumberIntVal(2), }, cty.Tuple([]cty.Type{cty.String, cty.DynamicPseudoType, cty.Number}), ) if err != nil { panic(err) } stringVal := cty.StringVal("TeSt") numberIntVal := cty.NumberIntVal(12) numberFloatVal := cty.NumberFloatVal(-12.23) boolVal := cty.BoolVal(false) fmt.Printf("Null: %#v\n", string(tokens.Generate(&cty.NilVal).Bytes())) fmt.Printf("Ident: %#v\n", string(tokens.Generate(tokens.NewIdentValue("TeSt")).Bytes())) fmt.Printf("String: %#v\n", string(tokens.Generate(&stringVal).Bytes())) fmt.Printf("Positive number: %#v\n", string(tokens.Generate(&numberIntVal).Bytes())) fmt.Printf("Negative number: %#v\n", string(tokens.Generate(&numberFloatVal).Bytes())) fmt.Printf("Boolean: %#v\n", string(tokens.Generate(&boolVal).Bytes())) fmt.Printf("List of capsule: %#v\n", string(tokens.Generate(&listOfCapsule).Bytes())) fmt.Printf("Set of capsule: %#v\n", string(tokens.Generate(&setOfCapsule).Bytes())) fmt.Printf("Object with capsule: %#v\n", string(tokens.Generate(&objectWithCapsule).Bytes())) fmt.Printf("Map of capsule: %#v\n", string(tokens.Generate(&mapOfCapsule).Bytes())) fmt.Printf("Tuple with capsule: %#v\n", string(tokens.Generate(&tupleWithCapsule).Bytes())) }
Output: Null: "null" Ident: "TeSt" String: "\"TeSt\"" Positive number: "12" Negative number: "-12.23" Boolean: "false" List of capsule: "[value1,value2]" Set of capsule: "[value1,value2]" Object with capsule: "{\n\"A\"=A_value\n\"B\"=\"B_value\"\n}" Map of capsule: "{\n\"A\"=A_value\n\"B\"=B_value\n}" Tuple with capsule: "[\"A_value\",B_value,2]"
func GenerateFromIterable ¶
GenerateFromIterable takes a list of `hclwrite.Tokens` and create related `hclwrite.Tokens` based on the provided `cty.Type`
It panics if provided type is not an iterable type.
func IsCapsuleType ¶
IsCapsuleType returns true if provided `cty.Type` is a special capsule encapsulating `hclwrite.Tokens`.
func MergeIterableAndGenerate ¶
MergeIterableAndGenerate takes a `cty.Value` collection, append new elements and convert the result to related `hclwrite.Tokens`
It panics if provided collection is not iterable.
func NewCommaToken ¶
NewCommaToken returns a `hclwrite.Token` with `hclsyntax.TokenComma` type.
func NewCommaTokens ¶
NewCommaTokens creates a `hclwrite.Tokens` containing a `hclwrite.Token` with `hclsyntax.TokenComma` type
See also `NewCommaToken()`.
func NewEqualToken ¶
NewEqualToken returns a `hclwrite.Token` with `hclsyntax.TokenEqual` type.
func NewEqualTokens ¶
NewEqualTokens creates a `hclwrite.Tokens` containing a `hclwrite.Token` with `hclsyntax.TokenEqual` type
See also `NewEqualToken()`.
func NewIdentListValue ¶
NewIdentListValue takes a list of string which should be all considered as 'ident' tokens and converts them into a cty list containing special `cty.Value` capsule.
Example ¶
package main import ( "fmt" "github.com/hashicorp/hcl/v2/hclwrite" "github.com/yoanm/go-tfsig/tokens" ) func main() { identListStringValue := []string{"explicit_ident_item.foo", "explicit_ident_item.bar"} value := tokens.NewIdentListValue(identListStringValue) // ... Later in the code hclFile := hclwrite.NewEmptyFile() hclFile.Body().SetAttributeRaw("attr", tokens.Generate(value)) fmt.Println(string(hclFile.Bytes())) }
Output: attr = [explicit_ident_item.foo, explicit_ident_item.bar]
func NewIdentToken ¶
NewIdentToken returns a `hclwrite.Token` with `hclsyntax.TokenIdent` type encapsulating provided bytes.
func NewIdentTokens ¶
NewIdentTokens takes a string and convert it to `hclwrite.Tokens` containing a `hclwrite.Token` with `hclsyntax.TokenIdent` type
See also `NewIdentToken()`.
func NewIdentValue ¶
NewIdentValue takes a string which should be considered as 'ident' token and converts it to a special `cty.Value` capsule.
Example ¶
package main import ( "fmt" "github.com/hashicorp/hcl/v2/hclwrite" "github.com/yoanm/go-tfsig/tokens" ) func main() { identStringValue := "explicit_ident.foo" value := tokens.NewIdentValue(identStringValue) // ... Later in the code hclFile := hclwrite.NewEmptyFile() hclFile.Body().SetAttributeRaw("attr", tokens.Generate(value)) fmt.Println(string(hclFile.Bytes())) }
Output: attr = explicit_ident.foo
func NewLineToken ¶
NewLineToken returns a `hclwrite.Token` with `hclsyntax.TokenNewline` type.
func NewLineTokens ¶
NewLineTokens creates a `hclwrite.Tokens` containing a `hclwrite.Token` with `hclsyntax.TokenNewline` type
See also `NewLineToken()`.
func SplitIterable ¶
SplitIterable takes a `cty.Value` collection and returns the start tokens, the existing elements tokens and the end tokens
It can be used to later append new elements to the collection (see `MergeIterableAndGenerate()`)
It panics if provided collection is not iterable.
Example ¶
package main import ( "fmt" "github.com/zclconf/go-cty/cty" "github.com/zclconf/go-cty/cty/gocty" "github.com/yoanm/go-tfsig/tokens" ) func main() { list, err := gocty.ToCtyValue( []cty.Value{ cty.StringVal("value1"), cty.StringVal("value2"), }, cty.List(cty.String), ) if err != nil { panic(err) } setOfCapsule, err := gocty.ToCtyValue( []cty.Value{ cty.StringVal("value1"), cty.StringVal("value2"), }, cty.Set(cty.String), ) if err != nil { panic(err) } objectWithCapsule, err := gocty.ToCtyValue( map[string]cty.Value{ "A": cty.NumberIntVal(2), "B": cty.StringVal("B_value"), }, cty.Object( map[string]cty.Type{ "A": cty.Number, "B": cty.String, }, ), ) if err != nil { panic(err) } mapOfCapsule, err := gocty.ToCtyValue( map[string]cty.Value{ "A": cty.StringVal("A_value"), "B": cty.StringVal("B_value"), }, cty.Map(cty.String), ) if err != nil { panic(err) } tupleWithCapsule, err := gocty.ToCtyValue( []cty.Value{ cty.StringVal("A_value"), cty.NumberIntVal(2), }, cty.Tuple([]cty.Type{cty.String, cty.Number}), ) if err != nil { panic(err) } start, elements, end := tokens.SplitIterable(list) fmt.Printf( "List:\n\tStart: %#v\n\tElements: %#v\n\tEnd: %#v\n", string(start.Bytes()), string(elements.Bytes()), string(end.Bytes()), ) start, elements, end = tokens.SplitIterable(setOfCapsule) fmt.Printf( "Set:\n\tStart: %#v\n\tElements: %#v\n\tEnd: %#v\n", string(start.Bytes()), string(elements.Bytes()), string(end.Bytes()), ) start, elements, end = tokens.SplitIterable(objectWithCapsule) fmt.Printf( "Object:\n\tStart: %#v\n\tElements: %#v\n\tEnd: %#v\n", string(start.Bytes()), string(elements.Bytes()), string(end.Bytes()), ) start, elements, end = tokens.SplitIterable(mapOfCapsule) fmt.Printf( "Map:\n\tStart: %#v\n\tElements: %#v\n\tEnd: %#v\n", string(start.Bytes()), string(elements.Bytes()), string(end.Bytes()), ) start, elements, end = tokens.SplitIterable(tupleWithCapsule) fmt.Printf( "Tuple:\n\tStart: %#v\n\tElements: %#v\n\tEnd: %#v\n", string(start.Bytes()), string(elements.Bytes()), string(end.Bytes()), ) }
Output: List: Start: "[" Elements: "\"value1\", \"value2\"" End: "]" Set: Start: "[" Elements: "\"value1\", \"value2\"" End: "]" Object: Start: "{" Elements: "\n A = 2\n B = \"B_value\"\n" End: "}" Map: Start: "{" Elements: "\n A = \"A_value\"\n B = \"B_value\"\n" End: "}" Tuple: Start: "[" Elements: "\"A_value\", 2" End: "]"
Types ¶
This section is empty.