mirror of
https://github.com/opentofu/opentofu.git
synced 2025-02-25 18:45:20 -06:00
repl: break typeString into some smaller functions
This function was too long for our function length linting rule, so we'll split each of the type kinds with special handling into their own function and thus the main typeString function is just a straightforward dispatch table with only one statement per case. Signed-off-by: Martin Atkins <mart@degeneration.co.uk>
This commit is contained in:
Martin Atkins
parent
6cc3fc6a07
commit
da8a2ecfce
@ -104,16 +104,13 @@ Control-D.
|
||||
return strings.TrimSpace(text), nil
|
||||
}
|
||||
|
||||
// Modified copy of TypeString from go-cty:
|
||||
// typeString returns a string representation of a given type that is
|
||||
// reminiscent of the OpenTofu type constraint syntax that might be used
|
||||
// to declare the type as part of an input variable declaration.
|
||||
//
|
||||
// This is a modified copy of TypeString from go-cty-debug, adapted to
|
||||
// produce HCL-like type expressions instead of Go expressions:
|
||||
// https://github.com/zclconf/go-cty-debug/blob/master/ctydebug/type_string.go
|
||||
//
|
||||
// TypeString returns a string representation of a given type that is
|
||||
// reminiscent of Go syntax calling into the cty package but is mainly
|
||||
// intended for easy human inspection of values in tests, debug output, etc.
|
||||
//
|
||||
// The resulting string will include newlines and indentation in order to
|
||||
// increase the readability of complex structures. It always ends with a
|
||||
// newline, so you can print this result directly to your output.
|
||||
func typeString(ty cty.Type) string {
|
||||
var b strings.Builder
|
||||
writeType(ty, &b, 0)
|
||||
@ -123,81 +120,13 @@ func typeString(ty cty.Type) string {
|
||||
func writeType(ty cty.Type, b *strings.Builder, indent int) {
|
||||
switch {
|
||||
case ty == cty.NilType:
|
||||
b.WriteString("nil")
|
||||
return
|
||||
b.WriteString("nil") // not actually a useful type to print, but handled for robustness
|
||||
case ty.IsObjectType():
|
||||
atys := ty.AttributeTypes()
|
||||
if len(atys) == 0 {
|
||||
b.WriteString("object({})")
|
||||
return
|
||||
}
|
||||
attrNames := make([]string, 0, len(atys))
|
||||
for name := range atys {
|
||||
attrNames = append(attrNames, name)
|
||||
}
|
||||
sort.Strings(attrNames)
|
||||
b.WriteString("object({\n")
|
||||
indent++
|
||||
for _, name := range attrNames {
|
||||
aty := atys[name]
|
||||
b.WriteString(indentSpaces(indent))
|
||||
fmt.Fprintf(b, "%s: ", name)
|
||||
writeType(aty, b, indent)
|
||||
b.WriteString(",\n")
|
||||
}
|
||||
indent--
|
||||
b.WriteString(indentSpaces(indent))
|
||||
b.WriteString("})")
|
||||
writeObjectType(ty, b, indent)
|
||||
case ty.IsTupleType():
|
||||
etys := ty.TupleElementTypes()
|
||||
if len(etys) == 0 {
|
||||
b.WriteString("tuple([])")
|
||||
return
|
||||
}
|
||||
b.WriteString("tuple([\n")
|
||||
indent++
|
||||
for _, ety := range etys {
|
||||
b.WriteString(indentSpaces(indent))
|
||||
writeType(ety, b, indent)
|
||||
b.WriteString(",\n")
|
||||
}
|
||||
indent--
|
||||
b.WriteString(indentSpaces(indent))
|
||||
b.WriteString("])")
|
||||
writeTupleType(ty, b, indent)
|
||||
case ty.IsCollectionType():
|
||||
ety := ty.ElementType()
|
||||
switch {
|
||||
case ty.IsListType():
|
||||
b.WriteString("list(")
|
||||
case ty.IsMapType():
|
||||
b.WriteString("map(")
|
||||
case ty.IsSetType():
|
||||
b.WriteString("set(")
|
||||
default:
|
||||
// At the time of writing there are no other collection types,
|
||||
// but we'll be robust here and just pass through the GoString
|
||||
// of anything we don't recognize.
|
||||
b.WriteString(ty.FriendlyName())
|
||||
return
|
||||
}
|
||||
// Because object and tuple types render split over multiple
|
||||
// lines, a collection type container around them can end up
|
||||
// being hard to see when scanning, so we'll generate some extra
|
||||
// indentation to make a collection of structural type more visually
|
||||
// distinct from the structural type alone.
|
||||
complexElem := ety.IsObjectType() || ety.IsTupleType()
|
||||
if complexElem {
|
||||
indent++
|
||||
b.WriteString("\n")
|
||||
b.WriteString(indentSpaces(indent))
|
||||
}
|
||||
writeType(ty.ElementType(), b, indent)
|
||||
if complexElem {
|
||||
indent--
|
||||
b.WriteString(",\n")
|
||||
b.WriteString(indentSpaces(indent))
|
||||
}
|
||||
b.WriteString(")")
|
||||
writeCollectionType(ty, b, indent)
|
||||
default:
|
||||
// For any other type we'll just use its GoString and assume it'll
|
||||
// follow the usual GoString conventions.
|
||||
@ -205,6 +134,85 @@ func writeType(ty cty.Type, b *strings.Builder, indent int) {
|
||||
}
|
||||
}
|
||||
|
||||
func writeObjectType(ty cty.Type, b *strings.Builder, indent int) {
|
||||
atys := ty.AttributeTypes()
|
||||
if len(atys) == 0 {
|
||||
b.WriteString("object({})")
|
||||
return
|
||||
}
|
||||
attrNames := make([]string, 0, len(atys))
|
||||
for name := range atys {
|
||||
attrNames = append(attrNames, name)
|
||||
}
|
||||
sort.Strings(attrNames)
|
||||
b.WriteString("object({\n")
|
||||
indent++
|
||||
for _, name := range attrNames {
|
||||
aty := atys[name]
|
||||
b.WriteString(indentSpaces(indent))
|
||||
fmt.Fprintf(b, "%s: ", name)
|
||||
writeType(aty, b, indent)
|
||||
b.WriteString(",\n")
|
||||
}
|
||||
indent--
|
||||
b.WriteString(indentSpaces(indent))
|
||||
b.WriteString("})")
|
||||
}
|
||||
|
||||
func writeTupleType(ty cty.Type, b *strings.Builder, indent int) {
|
||||
etys := ty.TupleElementTypes()
|
||||
if len(etys) == 0 {
|
||||
b.WriteString("tuple([])")
|
||||
return
|
||||
}
|
||||
b.WriteString("tuple([\n")
|
||||
indent++
|
||||
for _, ety := range etys {
|
||||
b.WriteString(indentSpaces(indent))
|
||||
writeType(ety, b, indent)
|
||||
b.WriteString(",\n")
|
||||
}
|
||||
indent--
|
||||
b.WriteString(indentSpaces(indent))
|
||||
b.WriteString("])")
|
||||
}
|
||||
|
||||
func writeCollectionType(ty cty.Type, b *strings.Builder, indent int) {
|
||||
ety := ty.ElementType()
|
||||
switch {
|
||||
case ty.IsListType():
|
||||
b.WriteString("list(")
|
||||
case ty.IsMapType():
|
||||
b.WriteString("map(")
|
||||
case ty.IsSetType():
|
||||
b.WriteString("set(")
|
||||
default:
|
||||
// At the time of writing there are no other collection types,
|
||||
// but we'll be robust here and just pass through the GoString
|
||||
// of anything we don't recognize.
|
||||
b.WriteString(ty.FriendlyName())
|
||||
return
|
||||
}
|
||||
// Because object and tuple types render split over multiple
|
||||
// lines, a collection type container around them can end up
|
||||
// being hard to see when scanning, so we'll generate some extra
|
||||
// indentation to make a collection of structural type more visually
|
||||
// distinct from the structural type alone.
|
||||
complexElem := ety.IsObjectType() || ety.IsTupleType()
|
||||
if complexElem {
|
||||
indent++
|
||||
b.WriteString("\n")
|
||||
b.WriteString(indentSpaces(indent))
|
||||
}
|
||||
writeType(ty.ElementType(), b, indent)
|
||||
if complexElem {
|
||||
indent--
|
||||
b.WriteString(",\n")
|
||||
b.WriteString(indentSpaces(indent))
|
||||
}
|
||||
b.WriteString(")")
|
||||
}
|
||||
|
||||
func indentSpaces(level int) string {
|
||||
return strings.Repeat(" ", level)
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user