Use go:embed to embed template files

Makefile

@@ -7,7 +7,6 @@ help:
 	@echo "    tidy         tidy go mod"
 
 generate:
-	go generate ./pkg/...
 	go generate ./...
 
 test:

internal/test/issues/issue-52/issue_test.go

@@ -1,6 +1,7 @@
 package issue_52
 
 import (
+	_ "embed"
 	"testing"
 
 	"github.com/getkin/kin-openapi/openapi3"
@@ -9,48 +10,11 @@ import (
 	"github.com/deepmap/oapi-codegen/pkg/codegen"
 )
 
-const spec = `
-openapi: 3.0.2
-info:
-  version: '0.0.1'
-  title: example
-  desscription: |
-    Make sure that recursive types are handled properly
-paths:
-  /example:
-    get:
-      operationId: exampleGet
-      responses:
-        '200':
-          description: "OK"
-          content:
-            'application/json':
-              schema:
-                $ref: '#/components/schemas/Document'
-components:
-  schemas:
-    Document:
-      type: object
-      properties:
-        fields:
-          type: object
-          additionalProperties:
-            $ref: '#/components/schemas/Value'
-    Value:
-      type: object
-      properties:
-        stringValue:
-          type: string
-        arrayValue:
-          $ref: '#/components/schemas/ArrayValue'
-    ArrayValue:
-      type: array
-      items:
-        $ref: '#/components/schemas/Value'
-`
+//go:embed spec.yaml
+var spec []byte
 
 func TestIssue(t *testing.T) {
-	swagger, err := openapi3.NewLoader().LoadFromData([]byte(spec))
+	swagger, err := openapi3.NewLoader().LoadFromData(spec)
 	require.NoError(t, err)
 
 	opts := codegen.Options{

internal/test/issues/issue-52/spec.yaml

@@ -2,7 +2,7 @@ openapi: 3.0.2
 info:
   version: '0.0.1'
   title: example
-  desscription: |
+  description: |
     Make sure that recursive types are handled properly
 paths:
   /example:

pkg/codegen/codegen.go

@@ -17,18 +17,22 @@ package codegen
 import (
 	"bufio"
 	"bytes"
+	"embed"
 	"fmt"
+	"io/fs"
 	"runtime/debug"
 	"sort"
 	"strings"
 	"text/template"
 
 	"github.com/getkin/kin-openapi/openapi3"
 	"golang.org/x/tools/imports"
-
-	"github.com/deepmap/oapi-codegen/pkg/codegen/templates"
 )
 
+// Embed the templates directory
+//go:embed templates
+var templates embed.FS
+
 // Options defines the optional code to generate.
 type Options struct {
 	GenerateChiServer  bool              // GenerateChiServer specifies whether to generate chi server boilerplate
@@ -116,7 +120,8 @@ func Generate(swagger *openapi3.T, packageName string, opts Options) (string, er
 	t := template.New("oapi-codegen").Funcs(TemplateFunctions)
 	// This parses all of our own template files into the template object
 	// above
-	t, err := templates.Parse(t)
+	err := LoadTemplates(templates, t)
+
 	if err != nil {
 		return "", fmt.Errorf("error parsing oapi-codegen templates: %w", err)
 	}
@@ -620,3 +625,29 @@ func SanitizeCode(goCode string) string {
 	// See: https://groups.google.com/forum/#!topic/golang-nuts/OToNIPdfkks
 	return strings.Replace(goCode, "\uFEFF", "", -1)
 }
+
+// LoadTemplates loads all of our template files into a text/template. The
+// path of template is relative to the templates directory.
+func LoadTemplates(src embed.FS, t *template.Template) error {
+	return fs.WalkDir(src, "templates", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return fmt.Errorf("error walking directory %s: %w", path, err)
+		}
+		if d.IsDir() {
+			return nil
+		}
+
+		buf, err := src.ReadFile(path)
+		if err != nil {
+			return fmt.Errorf("error reading file '%s': %w", path, err)
+		}
+
+		templateName := strings.TrimPrefix(path, "templates/")
+		tmpl := t.New(templateName)
+		_, err = tmpl.Parse(string(buf))
+		if err != nil {
+			return fmt.Errorf("parsing template '%s': %w", path, err)
+		}
+		return nil
+	})
+}

pkg/codegen/operations.go

@@ -660,19 +660,19 @@ func GenerateTypesForOperations(t *template.Template, ops []OperationDefinition)
 // GenerateChiServer This function generates all the go code for the ServerInterface as well as
 // all the wrapper functions around our handlers.
 func GenerateChiServer(t *template.Template, operations []OperationDefinition) (string, error) {
-	return GenerateTemplates([]string{"chi-interface.tmpl", "chi-middleware.tmpl", "chi-handler.tmpl"}, t, operations)
+	return GenerateTemplates([]string{"chi/chi-interface.tmpl", "chi/chi-middleware.tmpl", "chi/chi-handler.tmpl"}, t, operations)
 }
 
 // GenerateEchoServer This function generates all the go code for the ServerInterface as well as
 // all the wrapper functions around our handlers.
 func GenerateEchoServer(t *template.Template, operations []OperationDefinition) (string, error) {
-	return GenerateTemplates([]string{"echo-interface.tmpl", "echo-wrappers.tmpl", "echo-register.tmpl"}, t, operations)
+	return GenerateTemplates([]string{"echo/echo-interface.tmpl", "echo/echo-wrappers.tmpl", "echo/echo-register.tmpl"}, t, operations)
 }
 
 // GenerateGinServer This function generates all the go code for the ServerInterface as well as
 // all the wrapper functions around our handlers.
 func GenerateGinServer(t *template.Template, operations []OperationDefinition) (string, error) {
-	return GenerateTemplates([]string{"gin-interface.tmpl", "gin-wrappers.tmpl", "gin-register.tmpl"}, t, operations)
+	return GenerateTemplates([]string{"gin/gin-interface.tmpl", "gin/gin-wrappers.tmpl", "gin/gin-register.tmpl"}, t, operations)
 }
 
 // Uses the template engine to generate the function which registers our wrappers