Package Usage: go: github.com/jba/templatecheck
Package templatecheck checks Go templates for problems. It can detect many
errors that are normally caught only during execution. Use templatecheck
to find template errors early, and along template execution paths that
might only rarely be reached.
Given a template t from one of the text/template, html/template, or
github.com/google/safehtml/template packages, calling NewChecked[T](t)
type-checks t and returns a CheckedTemplate[T]. The only things you can do
with a CheckedTemplate[T] are get its name, and execute it with data of type
T.
The execution will be free of type errors. To make that guarantee, the
semantics of templates are restricted. CheckHTMLStrict has details, but the
general idea is that types must be known so they can be checked. For example,
the template
will succeed as long as dot contains a field or zero-argument method named "F".
The non-strict CheckXXX functions of this package will check that if the
type of dot is known, but if it is unknown or an interface type, they will
not complain, since template execution might succeed.
By contrast, strict checking will fail unless it can be sure
that the reference to "F" is valid, implying that it must know the type of dot.
When all of a program's templates are CheckedTemplates, it is not necessary
to write tests to check templates as described below. All type-checking
happens when the CheckedTemplates are created.
The rest of this documentation describes the original templatecheck mechanism,
accessed through the CheckXXX functions.
It may still be useful, especially for existing programs, but CheckedTemplate[T]
is preferable because it is safer.
A template must be invoked with the same Go type each time to use
the templatecheck.CheckXXX functions.
Passing that type to templatecheck gives it enough information
to verify that all the field references in the template are valid.
templatecheck can also verify that functions are called with the right number
and types of arguments, that the argument to a range statement can actually
be ranged over, and a few other things.
Consider a web server that parses a template for its home page:
Use templatecheck to catch errors in tests, instead of during serving:
To check associated templates, use Template.Lookup. This can be necessary for
non-strict checking if full type information isn't available to the main
template. (It isn't needed for strict checking, because all calls to
associated templates are type-checked.)
For example, here the base template is always invoked with a basePage,
but the type of its Details field differs depending on the value of IsTop.
The template text is
Checking only the main template will not provide much information about the
two associated templates, because their data types are unknown. All three
templates should be checked, like so:
7 versions
Latest release: almost 2 years ago
21 dependent packages
View more package details: https://packages.ecosystem.code.gouv.fr/registries/proxy.golang.org/packages/github.com/jba/templatecheck