Teach struct types to render themselves to go code.

Rather than including all go rendering logic in a large writeTypes function,
this patch teaches go structs that represent types and fields to render
themselves with Render() methods. Then we can write and test each Render method
independently, and combine them in writeTypes.

Author: jmcarp

internal/generate/templates/type.tpl

@@ -0,0 +1,9 @@
+{{splitDocString .Description}}
+{{if .Fields -}}
+type {{.Name}} {{.Type}} {
+{{range .Fields}}{{.Render}}
+{{- end}}}
+
+{{else -}}
+type {{.Name}} {{.Type}}
+{{end -}}

internal/generate/templates/type_field.tpl

@@ -0,0 +1,2 @@
+{{if .Description}}	{{splitDocString .Description}}
+{{end}}	{{.Name}} {{.Type}} {{.SerializationInfo}}

internal/generate/types.go

@@ -5,11 +5,13 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"os"
 	"slices"
 	"sort"
 	"strings"
+	"text/template"
 
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/iancoleman/strcase"
@@ -36,6 +38,24 @@ type TypeTemplate struct {
 	Fields []TypeFields
 }
 
+// Render renders the TypeTemplate as a string using a Go template.
+func (t TypeTemplate) Render() string {
+	funcMap := template.FuncMap{
+		"splitDocString": splitDocString,
+	}
+
+	tmpl, err := template.New("type.tpl").Funcs(funcMap).ParseFiles("./templates/type.tpl")
+	if err != nil {
+		panic(fmt.Sprintf("error parsing type.tpl: %v", err))
+	}
+
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, t); err != nil {
+		panic(fmt.Sprintf("error executing type.tpl: %v", err))
+	}
+	return buf.String()
+}
+
 // TypeFields holds the information for each type field
 type TypeFields struct {
 	Description       string
@@ -44,6 +64,24 @@ type TypeFields struct {
 	SerializationInfo string
 }
 
+// Render renders the TypeFields as a string using a Go template.
+func (f TypeFields) Render() string {
+	funcMap := template.FuncMap{
+		"splitDocString": splitDocString,
+	}
+
+	t, err := template.New("type_field.tpl").Funcs(funcMap).ParseFiles("./templates/type_field.tpl")
+	if err != nil {
+		panic(fmt.Sprintf("error parsing type_field.tpl: %v", err))
+	}
+
+	var buf bytes.Buffer
+	if err := t.Execute(&buf, f); err != nil {
+		panic(fmt.Sprintf("error executing type_field.tpl: %v", err))
+	}
+	return buf.String()
+}
+
 // EnumTemplate holds the information for enum types
 type EnumTemplate struct {
 	Description string
@@ -324,19 +362,7 @@ func writeTypes(f *os.File, typeCollection []TypeTemplate, typeValidationCollect
 			continue
 		}
 
-		fmt.Fprintf(f, "%s\n", splitDocString(tt.Description))
-		fmt.Fprintf(f, "type %s %s", tt.Name, tt.Type)
-		if tt.Fields != nil {
-			fmt.Fprint(f, " {\n")
-			for _, ft := range tt.Fields {
-				if ft.Description != "" {
-					fmt.Fprintf(f, "\t%s\n", splitDocString(ft.Description))
-				}
-				fmt.Fprintf(f, "\t%s %s %s\n", ft.Name, ft.Type, ft.SerializationInfo)
-			}
-			fmt.Fprint(f, "}\n")
-		}
-		fmt.Fprint(f, "\n")
+		fmt.Fprint(f, tt.Render())
 	}
 
 	// Write all collected validation methods to file

internal/generate/types_test.go

@@ -5,6 +5,7 @@
 package main
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/getkin/kin-openapi/openapi3"
@@ -344,3 +345,124 @@ func Test_createAllOf(t *testing.T) {
 		})
 	}
 }
+
+func Test_TypeFields_Render(t *testing.T) {
+	nameTag := "`json:\"name,omitempty\" yaml:\"name,omitempty\"`"
+
+	tests := []struct {
+		name  string
+		field TypeFields
+		want  string
+	}{
+		{
+			name: "field without description",
+			field: TypeFields{
+				Name:              "Name",
+				Type:              "string",
+				SerializationInfo: nameTag,
+			},
+			want: fmt.Sprintf(`	Name string %s
+`, nameTag),
+		},
+		{
+			name: "field with description",
+			field: TypeFields{
+				Description:       "// Name is the name of the resource",
+				Name:              "Name",
+				Type:              "string",
+				SerializationInfo: nameTag,
+			},
+			want: fmt.Sprintf(`	// Name is the name of the resource
+	Name string %s
+`, nameTag),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.field.Render()
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_TypeTemplate_Render(t *testing.T) {
+	nameTag := "`json:\"name,omitempty\" yaml:\"name,omitempty\"`"
+	streetTag := "`json:\"street\" yaml:\"street\"`"
+	cityTag := "`json:\"city\" yaml:\"city\"`"
+
+	tests := []struct {
+		name     string
+		template TypeTemplate
+		want     string
+	}{
+		{
+			name: "primitive type without fields",
+			template: TypeTemplate{
+				Description: "// FleetRole is the type definition for a FleetRole.",
+				Name:        "FleetRole",
+				Type:        "string",
+			},
+			want: `// FleetRole is the type definition for a FleetRole.
+type FleetRole string
+`,
+		},
+		{
+			name: "struct type with fields",
+			template: TypeTemplate{
+				Description: "// DiskIdentifier is the identifier for a disk.",
+				Name:        "DiskIdentifier",
+				Type:        "struct",
+				Fields: []TypeFields{
+					{
+						Name:              "Name",
+						Type:              "string",
+						SerializationInfo: nameTag,
+					},
+				},
+			},
+			want: fmt.Sprintf(`// DiskIdentifier is the identifier for a disk.
+type DiskIdentifier struct {
+	Name string %s
+}
+
+`, nameTag),
+		},
+		{
+			name: "struct type with field descriptions",
+			template: TypeTemplate{
+				Description: "// Address is an address.",
+				Name:        "Address",
+				Type:        "struct",
+				Fields: []TypeFields{
+					{
+						Description:       "// Street is the street name",
+						Name:              "Street",
+						Type:              "string",
+						SerializationInfo: streetTag,
+					},
+					{
+						Description:       "// City is the city name",
+						Name:              "City",
+						Type:              "string",
+						SerializationInfo: cityTag,
+					},
+				},
+			},
+			want: fmt.Sprintf(`// Address is an address.
+type Address struct {
+	// Street is the street name
+	Street string %s
+	// City is the city name
+	City string %s
+}
+
+`, streetTag, cityTag),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.template.Render()
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}