code review 4823056: exp/template: make Set.ParseFile etc resolve functions ...

src/pkg/exp/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 and sets easier.
 
 package template
 
 import (
         "fmt"
@@ skipping 17 matching lines @@
 // ParseFile reads the template definition from a file and parses it to
 // construct an internal representation of the template for execution.
 func (t *Template) ParseFile(filename string) os.Error {
         b, err := ioutil.ReadFile(filename)
         if err != nil {
                 return err
         }
         return t.Parse(string(b))
 }
 
+// ParseFileInSet is the same as ParseFile except that function bindings
+// are checked against those in the set and the template is added
+// to the set.
+func (t *Template) ParseFileInSet(filename string, set *Set) os.Error {
+        b, err := ioutil.ReadFile(filename)
+        if err != nil {
+                return err
+        }
+        return t.ParseInSet(string(b), set)
+}
+
 // MustParseFile reads the template definition from a file and parses it to
 // construct an internal representation of the template for execution.
 // It panics if the file cannot be read or the template cannot be parsed.
 func (t *Template) MustParseFile(filename string) *Template {
         if err := t.ParseFile(filename); err != nil {
                 panic(err)
         }
         return t
 }
 
 // ParseFile creates a new Template and parses the template definition from
 // the named file.  The template name is the base name of the file.
 func ParseFile(filename string) (*Template, os.Error) {
         t := New(filepath.Base(filename))
         return t, t.ParseFile(filename)
 }
 
+// ParseFileInSet creates a new Template and parses the template
+// definition from the named file. The template name is the base name
+// of the file. It also adds the template to the set. Function bindings are
+//checked against those in the set.
+func ParseFileInSet(filename string, set *Set) (*Template, os.Error) {
+        t := New(filepath.Base(filename))
+        return t, t.ParseFileInSet(filename, set)
+}
+
 // MustParseFile creates a new Template and parses the template definition
 // from the named file.  The template name is the base name of the file.
 // It panics if the file cannot be read or the template cannot be parsed.
 func MustParseFile(filename string) *Template {
         return New(filepath.Base(filename)).MustParseFile(filename)
 }
 
 // Functions and methods to parse a set.
 
 // MustParse parses a string into a set of named templates.
@@ skipping 107 matching lines @@
 // its file.
 // Unlike with ParseFile, each file should be a stand-alone template
 // definition suitable for Template.Parse (not Set.Parse); that is, the
 // file does not contain {{define}} clauses. ParseTemplateFile is
 // therefore equivalent to calling the ParseFile function to create
 // individual templates, which are then added to the set.
 // Each file must be parseable by itself. Parsing stops if an error is
 // encountered.
 func (s *Set) ParseTemplateFile(filenames ...string) os.Error {
         for _, filename := range filenames {
-                t, err := ParseFile(filename)
+                _, err := ParseFileInSet(filename, s)
                 if err != nil {
                         return err
                 }
-                if err := s.add(t); err != nil {
-                        return err
-                }
         }
         return nil
 }
 
 // MustParseTemplateFile is like ParseTemplateFile but
 // panics if there is an error.
 func (s *Set) MustParseTemplateFile(filenames ...string) *Set {
         err := s.ParseTemplateFile(filenames...)
         if err != nil {
                 panic(err)
@@ skipping 10 matching lines @@
 // therefore equivalent to calling the ParseFile function to create
 // individual templates, which are then added to the set.
 // Each file must be parseable by itself. Parsing stops if an error is
 // encountered.
 func (s *Set) ParseTemplateFiles(pattern string) os.Error {
         filenames, err := filepath.Glob(pattern)
         if err != nil {
                 return err
         }
         for _, filename := range filenames {
-                t, err := ParseFile(filename)
+                _, err := ParseFileInSet(filename, s)
                 if err != nil {
                         return err
                 }
-                if err := s.add(t); err != nil {
-                        return err
-                }
         }
         return nil
 }
 
 // MustParseTemplateFile is like ParseTemplateFiles but
 // panics if there is an error.
 func (s *Set) MustParseTemplateFiles(pattern string) *Set {
         err := s.ParseTemplateFiles(pattern)
         if err != nil {
                 panic(err)
@@ skipping 66 matching lines @@
 // MustParseTemplateFiles is like ParseTemplateFiles but
 // panics if there is a parse error or other problem
 // constructing the set.
 func MustParseTemplateFiles(pattern string) *Set {
         set, err := ParseTemplateFiles(pattern)
         if err != nil {
                 panic(err)
         }
         return set
 }