Source file src/pkg/text/template/helper.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Helper functions to make constructing templates easier.
     6	
     7	package template
     8	
     9	import (
    10		"fmt"
    11		"io/ioutil"
    12		"path/filepath"
    13	)
    14	
    15	// Functions and methods to parse templates.
    16	
    17	// Must is a helper that wraps a call to a function returning (*Template, error)
    18	// and panics if the error is non-nil. It is intended for use in variable
    19	// initializations such as
    20	//	var t = template.Must(template.New("name").Parse("text"))
    21	func Must(t *Template, err error) *Template {
    22		if err != nil {
    23			panic(err)
    24		}
    25		return t
    26	}
    27	
    28	// ParseFiles creates a new Template and parses the template definitions from
    29	// the named files. The returned template's name will have the (base) name and
    30	// (parsed) contents of the first file. There must be at least one file.
    31	// If an error occurs, parsing stops and the returned *Template is nil.
    32	func ParseFiles(filenames ...string) (*Template, error) {
    33		return parseFiles(nil, filenames...)
    34	}
    35	
    36	// ParseFiles parses the named files and associates the resulting templates with
    37	// t. If an error occurs, parsing stops and the returned template is nil;
    38	// otherwise it is t. There must be at least one file.
    39	func (t *Template) ParseFiles(filenames ...string) (*Template, error) {
    40		return parseFiles(t, filenames...)
    41	}
    42	
    43	// parseFiles is the helper for the method and function. If the argument
    44	// template is nil, it is created from the first file.
    45	func parseFiles(t *Template, filenames ...string) (*Template, error) {
    46		if len(filenames) == 0 {
    47			// Not really a problem, but be consistent.
    48			return nil, fmt.Errorf("template: no files named in call to ParseFiles")
    49		}
    50		for _, filename := range filenames {
    51			b, err := ioutil.ReadFile(filename)
    52			if err != nil {
    53				return nil, err
    54			}
    55			s := string(b)
    56			name := filepath.Base(filename)
    57			// First template becomes return value if not already defined,
    58			// and we use that one for subsequent New calls to associate
    59			// all the templates together. Also, if this file has the same name
    60			// as t, this file becomes the contents of t, so
    61			//  t, err := New(name).Funcs(xxx).ParseFiles(name)
    62			// works. Otherwise we create a new template associated with t.
    63			var tmpl *Template
    64			if t == nil {
    65				t = New(name)
    66			}
    67			if name == t.Name() {
    68				tmpl = t
    69			} else {
    70				tmpl = t.New(name)
    71			}
    72			_, err = tmpl.Parse(s)
    73			if err != nil {
    74				return nil, err
    75			}
    76		}
    77		return t, nil
    78	}
    79	
    80	// ParseGlob creates a new Template and parses the template definitions from the
    81	// files identified by the pattern, which must match at least one file. The
    82	// returned template will have the (base) name and (parsed) contents of the
    83	// first file matched by the pattern. ParseGlob is equivalent to calling
    84	// ParseFiles with the list of files matched by the pattern.
    85	func ParseGlob(pattern string) (*Template, error) {
    86		return parseGlob(nil, pattern)
    87	}
    88	
    89	// ParseGlob parses the template definitions in the files identified by the
    90	// pattern and associates the resulting templates with t. The pattern is
    91	// processed by filepath.Glob and must match at least one file. ParseGlob is
    92	// equivalent to calling t.ParseFiles with the list of files matched by the
    93	// pattern.
    94	func (t *Template) ParseGlob(pattern string) (*Template, error) {
    95		return parseGlob(t, pattern)
    96	}
    97	
    98	// parseGlob is the implementation of the function and method ParseGlob.
    99	func parseGlob(t *Template, pattern string) (*Template, error) {
   100		filenames, err := filepath.Glob(pattern)
   101		if err != nil {
   102			return nil, err
   103		}
   104		if len(filenames) == 0 {
   105			return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
   106		}
   107		return parseFiles(t, filenames...)
   108	}