type Template … var escapeOK … type nameSpace … // Templates returns a slice of the templates associated with t, including t // itself. func (t *Template) Templates() []*Template { … } // Option sets options for the template. Options are described by // strings, either a simple string or "key=value". There can be at // most one equals sign in an option string. If the option string // is unrecognized or otherwise invalid, Option panics. // // Known options: // // missingkey: Control the behavior during execution if a map is // indexed with a key that is not present in the map. // // "missingkey=default" or "missingkey=invalid" // The default behavior: Do nothing and continue execution. // If printed, the result of the index operation is the string // "<no value>". // "missingkey=zero" // The operation returns the zero value for the map type's element. // "missingkey=error" // Execution stops immediately with an error. func (t *Template) Option(opt ...string) *Template { … } // checkCanParse checks whether it is OK to parse templates. // If not, it returns an error. func (t *Template) checkCanParse() error { … } // escape escapes all associated templates. func (t *Template) escape() error { … } // Execute applies a parsed template to the specified data object, // writing the output to wr. // If an error occurs executing the template or writing its output, // execution stops, but partial results may already have been written to // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. func (t *Template) Execute(wr io.Writer, data any) error { … } // ExecuteTemplate applies the template associated with t that has the given // name to the specified data object and writes the output to wr. // If an error occurs executing the template or writing its output, // execution stops, but partial results may already have been written to // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error { … } // lookupAndEscapeTemplate guarantees that the template with the given name // is escaped, or returns an error if it cannot be. It returns the named // template. func (t *Template) lookupAndEscapeTemplate(name string) (tmpl *Template, err error) { … } // DefinedTemplates returns a string listing the defined templates, // prefixed by the string "; defined templates are: ". If there are none, // it returns the empty string. Used to generate an error message. func (t *Template) DefinedTemplates() string { … } // Parse parses text as a template body for t. // Named template definitions ({{define ...}} or {{block ...}} statements) in text // define additional templates associated with t and are removed from the // definition of t itself. // // Templates can be redefined in successive calls to Parse, // before the first use of [Template.Execute] on t or any associated template. // A template definition with a body containing only white space and comments // is considered empty and will not replace an existing template's body. // This allows using Parse to add new named template definitions without // overwriting the main template body. func (t *Template) Parse(text string) (*Template, error) { … } // AddParseTree creates a new template with the name and parse tree // and associates it with t. // // It returns an error if t or any associated template has already been executed. func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) { … } // Clone returns a duplicate of the template, including all associated // templates. The actual representation is not copied, but the name space of // associated templates is, so further calls to [Template.Parse] in the copy will add // templates to the copy but not to the original. [Template.Clone] can be used to prepare // common templates and use them with variant definitions for other templates // by adding the variants after the clone is made. // // It returns an error if t has already been executed. func (t *Template) Clone() (*Template, error) { … } // New allocates a new HTML template with the given name. func New(name string) *Template { … } // New allocates a new HTML template associated with the given one // and with the same delimiters. The association, which is transitive, // allows one template to invoke another with a {{template}} action. // // If a template with the given name already exists, the new HTML template // will replace it. The existing template will be reset and disassociated with // t. func (t *Template) New(name string) *Template { … } // new is the implementation of New, without the lock. func (t *Template) new(name string) *Template { … } // Name returns the name of the template. func (t *Template) Name() string { … } type FuncMap … // Funcs adds the elements of the argument map to the template's function map. // It must be called before the template is parsed. // It panics if a value in the map is not a function with appropriate return // type. However, it is legal to overwrite elements of the map. The return // value is the template, so calls can be chained. func (t *Template) Funcs(funcMap FuncMap) *Template { … } // Delims sets the action delimiters to the specified strings, to be used in // subsequent calls to [Template.Parse], [ParseFiles], or [ParseGlob]. Nested template // definitions will inherit the settings. An empty delimiter stands for the // corresponding default: {{ or }}. // The return value is the template, so calls can be chained. func (t *Template) Delims(left, right string) *Template { … } // Lookup returns the template with the given name that is associated with t, // or nil if there is no such template. func (t *Template) Lookup(name string) *Template { … } // Must is a helper that wraps a call to a function returning ([*Template], error) // and panics if the error is non-nil. It is intended for use in variable initializations // such as // // var t = template.Must(template.New("name").Parse("html")) func Must(t *Template, err error) *Template { … } // ParseFiles creates a new [Template] and parses the template definitions from // the named files. The returned template's name will have the (base) name and // (parsed) contents of the first file. There must be at least one file. // If an error occurs, parsing stops and the returned [*Template] is nil. // // When parsing multiple files with the same name in different directories, // the last one mentioned will be the one that results. // For instance, ParseFiles("a/foo", "b/foo") stores "b/foo" as the template // named "foo", while "a/foo" is unavailable. func ParseFiles(filenames ...string) (*Template, error) { … } // ParseFiles parses the named files and associates the resulting templates with // t. If an error occurs, parsing stops and the returned template is nil; // otherwise it is t. There must be at least one file. // // When parsing multiple files with the same name in different directories, // the last one mentioned will be the one that results. // // ParseFiles returns an error if t or any associated template has already been executed. func (t *Template) ParseFiles(filenames ...string) (*Template, error) { … } // parseFiles is the helper for the method and function. If the argument // template is nil, it is created from the first file. func parseFiles(t *Template, readFile func(string) (string, []byte, error), filenames ...string) (*Template, error) { … } // ParseGlob creates a new [Template] and parses the template definitions from // the files identified by the pattern. The files are matched according to the // semantics of filepath.Match, and the pattern must match at least one file. // The returned template will have the (base) name and (parsed) contents of the // first file matched by the pattern. ParseGlob is equivalent to calling // [ParseFiles] with the list of files matched by the pattern. // // When parsing multiple files with the same name in different directories, // the last one mentioned will be the one that results. func ParseGlob(pattern string) (*Template, error) { … } // ParseGlob parses the template definitions in the files identified by the // pattern and associates the resulting templates with t. The files are matched // according to the semantics of filepath.Match, and the pattern must match at // least one file. ParseGlob is equivalent to calling t.ParseFiles with the // list of files matched by the pattern. // // When parsing multiple files with the same name in different directories, // the last one mentioned will be the one that results. // // ParseGlob returns an error if t or any associated template has already been executed. func (t *Template) ParseGlob(pattern string) (*Template, error) { … } // parseGlob is the implementation of the function and method ParseGlob. func parseGlob(t *Template, pattern string) (*Template, error) { … } // IsTrue reports whether the value is 'true', in the sense of not the zero of its type, // and whether the value has a meaningful truth value. This is the definition of // truth used by if and other such actions. func IsTrue(val any) (truth, ok bool) { … } // ParseFS is like [ParseFiles] or [ParseGlob] but reads from the file system fs // instead of the host operating system's file system. // It accepts a list of glob patterns. // (Note that most file names serve as glob patterns matching only themselves.) func ParseFS(fs fs.FS, patterns ...string) (*Template, error) { … } // ParseFS is like [Template.ParseFiles] or [Template.ParseGlob] but reads from the file system fs // instead of the host operating system's file system. // It accepts a list of glob patterns. // (Note that most file names serve as glob patterns matching only themselves.) func (t *Template) ParseFS(fs fs.FS, patterns ...string) (*Template, error) { … } func parseFS(t *Template, fsys fs.FS, patterns []string) (*Template, error) { … } func readFileOS(file string) (name string, b []byte, err error) { … } func readFileFS(fsys fs.FS) func(string) (string, []byte, error) { … }
Codebase Browser
go