...
Run Format

Source file src/text/template/helper.go

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // Helper functions to make constructing templates easier.
  
  package template
  
  import (
  	"fmt"
  	"io/ioutil"
  	"path/filepath"
  )
  
  // Functions and methods to parse templates.
  
  // 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("text"))
  func Must(t *Template, err error) *Template {
  	if err != nil {
  		panic(err)
  	}
  	return t
  }
  
  // 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) {
  	return parseFiles(nil, filenames...)
  }
  
  // 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.
  // Since the templates created by ParseFiles are named by the base
  // names of the argument files, t should usually have the name of one
  // of the (base) names of the files. If it does not, depending on t's
  // contents before calling ParseFiles, t.Execute may fail. In that
  // case use t.ExecuteTemplate to execute a valid template.
  //
  // When parsing multiple files with the same name in different directories,
  // the last one mentioned will be the one that results.
  func (t *Template) ParseFiles(filenames ...string) (*Template, error) {
  	t.init()
  	return parseFiles(t, filenames...)
  }
  
  // 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, filenames ...string) (*Template, error) {
  	if len(filenames) == 0 {
  		// Not really a problem, but be consistent.
  		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
  	}
  	for _, filename := range filenames {
  		b, err := ioutil.ReadFile(filename)
  		if err != nil {
  			return nil, err
  		}
  		s := string(b)
  		name := filepath.Base(filename)
  		// First template becomes return value if not already defined,
  		// and we use that one for subsequent New calls to associate
  		// all the templates together. Also, if this file has the same name
  		// as t, this file becomes the contents of t, so
  		//  t, err := New(name).Funcs(xxx).ParseFiles(name)
  		// works. Otherwise we create a new template associated with t.
  		var tmpl *Template
  		if t == nil {
  			t = New(name)
  		}
  		if name == t.Name() {
  			tmpl = t
  		} else {
  			tmpl = t.New(name)
  		}
  		_, err = tmpl.Parse(s)
  		if err != nil {
  			return nil, err
  		}
  	}
  	return t, nil
  }
  
  // ParseGlob creates a new Template and parses the template definitions from the
  // files identified by the pattern, which 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) {
  	return parseGlob(nil, pattern)
  }
  
  // ParseGlob parses the template definitions in the files identified by the
  // pattern and associates the resulting templates with t. The pattern is
  // processed by filepath.Glob and 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.
  func (t *Template) ParseGlob(pattern string) (*Template, error) {
  	t.init()
  	return parseGlob(t, pattern)
  }
  
  // parseGlob is the implementation of the function and method ParseGlob.
  func parseGlob(t *Template, pattern string) (*Template, error) {
  	filenames, err := filepath.Glob(pattern)
  	if err != nil {
  		return nil, err
  	}
  	if len(filenames) == 0 {
  		return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
  	}
  	return parseFiles(t, filenames...)
  }
  

View as plain text