libgo/go/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 }