echo: remove mandatory templatesecho/v0.11.0

7 files changed, 219 insertions, 142 deletions

diff --git a/echo/controller/generic_template.go b/echo/controller/generic_template.go
index 190182b..bd64304 100644
--- a/echo/controller/generic_template.go
+++ b/echo/controller/generic_template.go
@@ -80,7 +80,7 @@ func (h *GenericTemplateHandler) canonicalizeUrl(c echo.Context, tr glecho.Templ
                 path = "index.tpl"
         } else if !strings.HasSuffix(path, ".html") {
                 p := fmt.Sprintf("%s.tpl", path)
-                if !tr.HaveTemplate(c, p) {
+                if !tr.HaveTemplate(p) {
                         path = fmt.Sprintf("%s/index.tpl", path)
                 } else {
                         path = p
diff --git a/echo/echo_default.go b/echo/echo_default.go
index 76f543d..ff3c754 100644
--- a/echo/echo_default.go
+++ b/echo/echo_default.go
@@ -22,17 +22,8 @@ import (
 
 // Docs: https://echo.labstack.com/guide/
 
-// TODO:
-// - Integrate CSRF
-// - Integrate session
-
 const defaultBodySizeLimit = "10M"
 
-var mandatoryTemplates = []string{
-        "404.tpl", "40x.tpl", "50x.tpl",
-        "header.tpl", "footer.tpl",
-}
-
 func makeMiddlewareSkipper(c *prometheus.PrometheusConfig) middleware.Skipper {
         var path string
 
@@ -209,21 +200,17 @@ func (w *EchoWrapper) configureTemplates(c *EchoConfig) error {
                 templates = c.EmbeddedTemplates
         }
 
-        // Only install template handlers if the path and glob are set
+        // Only install template handlers if the path is set
         if templates != nil {
-                w.HTTPErrorHandler = ErrorHandler(templates, c.TemplateFunctions)
-
-                tr, err := NewTemplateRenderer(templates, "*.tpl", c.TemplateFunctions)
+                tr, err := NewTemplateRenderer(templates, "*.tpl", c.TemplateFunctions, w.Debug)
                 if err != nil {
                         return fmt.Errorf("Error loading template renderer: %w", err)
                 }
-                w.Renderer = tr
 
-                for _, t := range mandatoryTemplates {
-                        if !tr.HaveTemplate(w.NewContext(nil, nil), t) {
-                                return fmt.Errorf("Template renderer is missing required template %s", t)
-                        }
-                }
+                w.HTTPErrorHandler = NewDefaultErrorHandler(tr).HandleError
+                w.Renderer = tr
+        } else {
+                w.HTTPErrorHandler = NewNoHTMLErrorHandler().HandleError
         }
 
         w.templateFS = templates
diff --git a/echo/error_handler.go b/echo/error_handler.go
index 2316ccd..b44155f 100644
--- a/echo/error_handler.go
+++ b/echo/error_handler.go
@@ -4,135 +4,193 @@ import (
         "bytes"
         "fmt"
         "html/template"
-        "io/fs"
         "net/http"
 
         "github.com/elnormous/contenttype"
         "github.com/labstack/echo/v4"
 )
 
-// TODO: This should allow plugging in other content types
-// TODO: This should also be refactored into something prettier
-func ErrorHandler(templates fs.FS, funcs template.FuncMap) func(error, echo.Context) {
-        handleHtml := func(c echo.Context, he *echo.HTTPError) error {
-                t, err := template.New("").Funcs(funcs).ParseFS(
-                        templates,
-                        "404.tpl",
-                        "40x.tpl",
-                        "50x.tpl",
-                        "header.tpl",
-                        "footer.tpl",
-                )
-                if err != nil {
-                        return err
-                }
+// TODO: This should have some kind of HTML formatting of panics in debug mode
 
-                path := "50x.tpl"
-                if he.Code == 404 {
-                        path = "404.tpl"
-                } else if he.Code >= 400 && he.Code <= 499 {
-                        path = "40x.tpl"
-                }
+type ContentErrorHandler interface {
+        Handle(echo.Context, *echo.HTTPError) error
+}
 
-                buf := bytes.Buffer{}
-                if err = t.ExecuteTemplate(&buf, path, nil); err != nil {
-                        err = c.String(he.Code, fmt.Sprintf("%s", he.Message))
-                }
+type HTMLErrorHandler struct {
+        r        *TemplateRenderer
+        fallback *template.Template
+}
 
-                return c.HTMLBlob(he.Code, buf.Bytes())
+func NewHTMLErrorHandler(r *TemplateRenderer) *HTMLErrorHandler {
+        t, err := template.New("").Parse("<html><body><h1>Error</h1><pre>{{ .Message }}</pre></body></html>\n")
+        if err != nil {
+                panic("NewHTMLErrorHandler: error parsing fallback template")
         }
+        return &HTMLErrorHandler{r: r, fallback: t}
+}
 
-        handlePlain := func(c echo.Context, he *echo.HTTPError) error {
-                return c.String(he.Code, fmt.Sprintf("%s", he.Message))
+func (h *HTMLErrorHandler) Handle(c echo.Context, e *echo.HTTPError) error {
+        path := "50x.tpl"
+        if e.Code == 404 {
+                path = "404.tpl"
+        } else if e.Code >= 400 && e.Code <= 499 {
+                path = "40x.tpl"
         }
 
-        handleJson := func(c echo.Context, he *echo.HTTPError) error {
-                code := he.Code
-                message := he.Message
-                if m, ok := he.Message.(string); ok {
-                        if c.Echo().Debug {
-                                message = echo.Map{"message": m, "error": he.Error()}
-                        } else {
-                                message = echo.Map{"message": m}
-                        }
-                }
+        buf := bytes.Buffer{}
+        if !h.r.HaveTemplate(path) {
+                c.Logger().Errorf("Error template %s is missing, using fallback", path)
 
-                return c.JSON(code, message)
+                if err := h.fallback.Execute(&buf, e); err != nil {
+                        c.Logger().Errorf("Error rendering HTML error page: %s", err)
+                        return c.String(e.Code, e.Error())
+                }
+        } else {
+                if err := h.r.Render(&buf, path, e, c); err != nil {
+                        c.Logger().Errorf("Error rendering HTML error page: %s", err)
+                        return c.String(e.Code, e.Error())
+                }
         }
 
-        errorWhileErroring := func(c echo.Context, err interface{}) {
-                c.Echo().Logger.Error(err)
+        return c.HTMLBlob(e.Code, buf.Bytes())
+}
+
+type PlainTextErrorHandler struct{}
+
+func (h *PlainTextErrorHandler) Handle(c echo.Context, e *echo.HTTPError) error {
+        return c.String(e.Code, fmt.Sprintf("%s", e.Message))
+}
+
+type JSONErrorHandler struct{}
+
+func (h *JSONErrorHandler) Handle(c echo.Context, e *echo.HTTPError) error {
+        code := e.Code
+        message := e.Message
+        if m, ok := e.Message.(string); ok {
                 if c.Echo().Debug {
-                        c.JSON(http.StatusInternalServerError, &echo.HTTPError{
-                                Code:    http.StatusInternalServerError,
-                                Message: fmt.Sprintf("Error while processing error page. %s", err),
-                        })
+                        message = echo.Map{"message": m, "error": e.Error()}
                 } else {
-                        c.JSON(http.StatusInternalServerError, &echo.HTTPError{
-                                Code:    http.StatusInternalServerError,
-                                Message: http.StatusText(http.StatusInternalServerError),
-                        })
+                        message = echo.Map{"message": m}
                 }
         }
 
-        handlers := map[string]func(echo.Context, *echo.HTTPError) error{
-                "text/plain":       handlePlain,
-                "text/html":        handleHtml,
-                "text/json":        handleJson,
-                "application/json": handleJson,
+        return c.JSON(code, message)
+}
+
+type failsafeHandler struct{}
+
+func (h *failsafeHandler) Handle(c echo.Context, e *echo.HTTPError) error {
+        c.Echo().Logger.Error("Error while processing error page: %s", e)
+        c.JSON(http.StatusInternalServerError, e)
+        return nil
+}
+
+type ErrorHandler struct {
+        types           []contenttype.MediaType
+        typeMap         map[string]ContentErrorHandler
+        failsafeHandler ContentErrorHandler
+}
+
+func NewErrorHandler() *ErrorHandler {
+        return &ErrorHandler{
+                types:           []contenttype.MediaType{},
+                typeMap:         map[string]ContentErrorHandler{},
+                failsafeHandler: &failsafeHandler{},
         }
+}
+
+func NewDefaultErrorHandler(tr *TemplateRenderer) *ErrorHandler {
+        h := NewErrorHandler()
+
+        // The order of these is important, especially when negotiating */*
+        h.AddHandler(&JSONErrorHandler{}, "text/json", "application/json")
+        h.AddHandler(&PlainTextErrorHandler{}, "text/plain")
+        h.AddHandler(NewHTMLErrorHandler(tr), "text/html")
+
+        return h
+}
+
+func NewNoHTMLErrorHandler() *ErrorHandler {
+        h := NewErrorHandler()
+
+        // The order of these is important, especially when negotiating */*
+        h.AddHandler(&JSONErrorHandler{}, "text/json", "application/json")
+        h.AddHandler(&PlainTextErrorHandler{}, "text/plain")
+
+        return h
+}
 
-        // This is hand maintained here because order is important for negotiation,
-        // especially in the case of */*
-        hIndex := []contenttype.MediaType{
-                contenttype.NewMediaType("text/json"),
-                contenttype.NewMediaType("application/json"),
-                contenttype.NewMediaType("text/plain"),
-                contenttype.NewMediaType("text/html"),
+func (h *ErrorHandler) AddHandler(eh ContentErrorHandler, contentTypes ...string) {
+        for _, ct := range contentTypes {
+                h.types = append(h.types, contenttype.NewMediaType(ct))
+                h.typeMap[ct] = eh
         }
+}
 
-        return func(err error, c echo.Context) {
-                defer func() {
-                        if r := recover(); r != nil {
-                                errorWhileErroring(c, r)
-                        }
-                }()
-
-                he, ok := err.(*echo.HTTPError)
-                if ok {
-                        if he.Internal != nil {
-                                if herr, ok := he.Internal.(*echo.HTTPError); ok {
-                                        he = herr
-                                }
-                        }
-                } else {
-                        he = &echo.HTTPError{
-                                Code:    http.StatusInternalServerError,
-                                Message: http.StatusText(http.StatusInternalServerError),
+func (h *ErrorHandler) castToHttpError(e error) *echo.HTTPError {
+        he, ok := e.(*echo.HTTPError)
+        if ok {
+                if he.Internal != nil {
+                        if ihe, ok := he.Internal.(*echo.HTTPError); ok {
+                                return ihe
                         }
                 }
-
-                ct, _, err := contenttype.GetAcceptableMediaType(c.Request(), hIndex)
-                if err != nil {
-                        c.Echo().Logger.Error("Error negotiating content type in error handler, using json")
-                        ct = contenttype.NewMediaType("text/json")
+                return he
+        } else {
+                return &echo.HTTPError{
+                        Code:    http.StatusInternalServerError,
+                        Message: http.StatusText(http.StatusInternalServerError),
                 }
+        }
+}
 
-                handle, ok := handlers[ct.String()]
-                if !ok {
-                        c.Echo().Logger.Errorf("Error handler content type %s is unknown", ct.String())
-                        handle = handleJson
-                }
+func (h *ErrorHandler) negotiateContentType(r *http.Request) (ContentErrorHandler, error) {
+        var err error
 
-                if !c.Response().Committed {
-                        if c.Request().Method == http.MethodHead { // Issue #608
-                                err = c.NoContent(he.Code)
+        ct, _, err := contenttype.GetAcceptableMediaType(r, h.types)
+        if err != nil {
+                err = fmt.Errorf("Error negotiating content type in error handler, falling back to JSON: %w", err)
+                ct = contenttype.NewMediaType("text/json")
+        }
+
+        handle, found := h.typeMap[ct.String()]
+        if !found {
+                err = fmt.Errorf("Unable to find handler for content type: %s", ct)
+                handle = h.failsafeHandler
+        }
+
+        return handle, err
+}
+
+func (h *ErrorHandler) HandleError(err error, c echo.Context) {
+        defer func() {
+                if r := recover(); r != nil {
+                        if err, ok := r.(error); !ok {
+                                h.failsafeHandler.Handle(c, h.castToHttpError(fmt.Errorf("%s", err)))
                         } else {
-                                err = handle(c, he)
-                        }
-                        if err != nil {
-                                errorWhileErroring(c, err)
+                                h.failsafeHandler.Handle(c, h.castToHttpError(err))
                         }
                 }
+        }()
+
+        logger := c.Echo().Logger
+        he := h.castToHttpError(err)
+
+        handle, cterr := h.negotiateContentType(c.Request())
+        if cterr != nil {
+                logger.Errorf("%s", cterr)
+        }
+
+        if !c.Response().Committed {
+                if c.Request().Method == http.MethodHead { // Issue #608
+                        err = c.NoContent(he.Code)
+                } else {
+                        err = handle.Handle(c, he)
+                }
+                if err != nil {
+                        h.failsafeHandler.Handle(c, h.castToHttpError(err))
+                }
+        } else {
+                logger.Errorf("Error occurred in committed response: %s", he)
         }
 }
diff --git a/echo/go.mod b/echo/go.mod
index fcedf30..782c6e8 100644
--- a/echo/go.mod
+++ b/echo/go.mod
@@ -66,10 +66,10 @@ require (
         github.com/valyala/bytebufferpool v1.0.0 // indirect
         github.com/valyala/fasttemplate v1.2.1 // indirect
         go.uber.org/atomic v1.9.0 // indirect
-        golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
-        golang.org/x/net v0.0.0-20210913180222-943fd674d43e // indirect
-        golang.org/x/sys v0.0.0-20211103235746-7861aae1554b // indirect
-        golang.org/x/text v0.3.7 // indirect
+        golang.org/x/crypto v0.11.0 // indirect
+        golang.org/x/net v0.10.0 // indirect
+        golang.org/x/sys v0.10.0 // indirect
+        golang.org/x/text v0.11.0 // indirect
         golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
         google.golang.org/genproto v0.0.0-20200825200019-8632dd797987 // indirect
         google.golang.org/grpc v1.41.0 // indirect
diff --git a/echo/go.sum b/echo/go.sum
index fe3ba40..3b58191 100644
--- a/echo/go.sum
+++ b/echo/go.sum
@@ -370,8 +370,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -433,8 +433,9 @@ golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210913180222-943fd674d43e h1:+b/22bPvDYt4NPDcy4xAGCmON713ONAWFeY3Z7I3tR8=
 golang.org/x/net v0.0.0-20210913180222-943fd674d43e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -494,8 +495,9 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210910150752-751e447fb3d0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211103235746-7861aae1554b h1:1VkfZQv42XQlA/jchYumAnv1UPo6RgF9rJFkTgZIxO4=
 golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -503,8 +505,9 @@ golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
diff --git a/echo/middleware/recover_middleware.go b/echo/middleware/recover_middleware.go
index 310e146..af4259a 100644
--- a/echo/middleware/recover_middleware.go
+++ b/echo/middleware/recover_middleware.go
@@ -1,9 +1,11 @@
 package middleware
 
 import (
+        "bytes"
         "fmt"
         "net/http"
         "runtime"
+        "text/template"
 
         "github.com/labstack/echo/v4"
         "github.com/labstack/echo/v4/middleware"
@@ -49,6 +51,16 @@ var (
                 DisablePrintStack: false,
                 LogLevel:          0,
         }
+        defaultErrorTemplate = `<html>
+                <head>
+                        <title>Error</title>
+                        <style type="text/css">
+                                pre { border: 1px solid black; padding: 1em; background: #f0f0f0; font-size: 1.5em; }
+                        </style>
+                </head>
+                <body><h1>Error</h1><pre>{{ . }}</pre></body>
+        </html>
+        `
 )
 
 // Recover returns a middleware which recovers from panics anywhere in the chain
@@ -68,6 +80,11 @@ func RecoverWithConfig(config RecoverConfig) echo.MiddlewareFunc {
                 config.StackSize = DefaultRecoverConfig.StackSize
         }
 
+        errorTemplate, err := template.New("").Parse(defaultErrorTemplate)
+        if err != nil {
+                panic("RecoverWithConfig: error parsing html template")
+        }
+
         return func(next echo.HandlerFunc) echo.HandlerFunc {
                 return func(c echo.Context) error {
                         if config.Skipper(c) {
@@ -100,8 +117,14 @@ func RecoverWithConfig(config RecoverConfig) echo.MiddlewareFunc {
                                                 }
                                         }
                                         if c.Echo().Debug {
-                                                msg := fmt.Sprintf("%v %s\n", err, stack[:length])
-                                                c.String(http.StatusInternalServerError, msg)
+                                                buf := bytes.Buffer{}
+                                                msg := fmt.Sprintf("%v\n\n%s", err, stack[:length])
+                                                if err := errorTemplate.Execute(&buf, msg); err != nil {
+                                                        c.Logger().Errorf("Error rendering HTML error page: %s", err)
+                                                        c.String(http.StatusInternalServerError, msg)
+                                                        return
+                                                }
+                                                c.HTMLBlob(http.StatusInternalServerError, buf.Bytes())
                                         } else {
                                                 c.Error(err)
                                         }
diff --git a/echo/template_renderer.go b/echo/template_renderer.go
index 7bfd006..8515249 100644
--- a/echo/template_renderer.go
+++ b/echo/template_renderer.go
@@ -11,7 +11,7 @@ import (
 )
 
 type TemplateChecker interface {
-        HaveTemplate(echo.Context, string) bool
+        HaveTemplate(string) bool
 }
 
 type TemplateRenderer struct {
@@ -19,12 +19,19 @@ type TemplateRenderer struct {
         glob      string
         funcs     template.FuncMap
         cache     *template.Template
+        debug     bool
 }
 
-func NewTemplateRenderer(templates fs.FS, glob string, funcs template.FuncMap) (*TemplateRenderer, error) {
+func NewTemplateRenderer(templates fs.FS, glob string, funcs template.FuncMap, debug bool) (*TemplateRenderer, error) {
         var err error
 
-        r := &TemplateRenderer{templates: templates, glob: glob, funcs: funcs}
+        r := &TemplateRenderer{
+                templates: templates,
+                glob:      glob,
+                funcs:     funcs,
+                debug:     debug,
+        }
+
         r.cache, err = r.loadTemplates()
         if err != nil {
                 return nil, err
@@ -65,22 +72,21 @@ func (r *TemplateRenderer) loadTemplates() (*template.Template, error) {
         return t, nil
 }
 
-func (r *TemplateRenderer) getTemplateCache(ctx echo.Context) (*template.Template, error) {
-        var err error
+func (r *TemplateRenderer) getTemplateCache() (*template.Template, error) {
+        if !r.debug {
+                return r.cache, nil
+        }
 
-        tc := r.cache
-        if ctx.Echo().Debug {
-                tc, err = r.loadTemplates()
-                if err != nil {
-                        return nil, err
-                }
+        tc, err := r.loadTemplates()
+        if err != nil {
+                return nil, err
         }
 
         return tc, nil
 }
 
 func (r *TemplateRenderer) Render(w io.Writer, name string, data interface{}, ctx echo.Context) error {
-        tc, err := r.getTemplateCache(ctx)
+        tc, err := r.getTemplateCache()
         if err != nil {
                 return err
         }
@@ -96,8 +102,8 @@ func (r *TemplateRenderer) Render(w io.Writer, name string, data interface{}, ct
         return nil
 }
 
-func (r *TemplateRenderer) HaveTemplate(ctx echo.Context, name string) bool {
-        tc, err := r.getTemplateCache(ctx)
+func (r *TemplateRenderer) HaveTemplate(name string) bool {
+        tc, err := r.getTemplateCache()
         if err != nil {
                 return false
         }