exp/template: the must-have MustParse functions

R=r
CC=golang-dev
https://golang.org/cl/4641096

diff --git a/src/pkg/exp/template/Makefile b/src/pkg/exp/template/Makefile
index 8550b0d522103fbbe20e7b1057d8c62204484d68..988791f3545b84814f67ac8e1b321ce9b6b4ce8c 100644 (file)
--- a/src/pkg/exp/template/Makefile
+++ b/src/pkg/exp/template/Makefile
@@ -8,6 +8,7 @@ TARG=exp/template
 GOFILES=\
        exec.go\
        funcs.go\
+       helper.go\
        lex.go\
        parse.go\
        set.go\

diff --git a/src/pkg/exp/template/helper.go b/src/pkg/exp/template/helper.go
new file mode 100644 (file)
index 0000000..def4f01
--- /dev/null
+++ b/src/pkg/exp/template/helper.go
@@ -0,0 +1,100 @@
+// 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 (
+       "io/ioutil"
+       "os"
+       "path/filepath"
+)
+
+// MustParse parses the template definition string to construct an internal
+// representation of the template for execution.
+// It panics if the template cannot be parsed.
+func (t *Template) MustParse(text string) *Template {
+       if err := t.Parse(text); err != nil {
+               panic(err)
+       }
+       return t
+}
+
+// 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))
+}
+
+// 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 is a helper function that 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)
+}
+
+// MustParseFile is a helper function that 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)
+}
+
+// MustParse parses a string into a set of named templates.
+// It panics if the set cannot be parsed.
+func (s *Set) MustParse(text string) *Set {
+       if err := s.Parse(text); err != nil {
+               panic(err)
+       }
+       return s
+}
+
+// ParseFile parses the named file into a set of named templates.
+func (s *Set) ParseFile(filename string) os.Error {
+       b, err := ioutil.ReadFile(filename)
+       if err != nil {
+               return err
+       }
+       return s.Parse(string(b))
+}
+
+// MustParseFile parses the named file into a set of named templates.
+// It panics if the file cannot be read or the set cannot be parsed.
+func (s *Set) MustParseFile(filename string) *Set {
+       if err := s.ParseFile(filename); err != nil {
+               panic(err)
+       }
+       return s
+}
+
+// ParseSetFile is a helper function that creates a new *Set and parses
+// the set definition from the named file.
+func ParseSetFile(filename string) (*Set, os.Error) {
+       s := NewSet()
+       return s, s.ParseFile(filename)
+}
+
+// MustParseSetFile is a helper function that creates a new *Set and parses
+// the set definition from the named file.
+// It panics if the file cannot be read or the set cannot be parsed.
+func MustParseSetFile(filename string) *Set {
+       return NewSet().MustParseFile(filename)
+}

diff --git a/src/pkg/exp/template/parse.go b/src/pkg/exp/template/parse.go
index 8b2d60207514d244f8949f77adcf751771bae42e..2b3cd17aba6b5739d555a0b8f72fb63c5d151143 100644 (file)
--- a/src/pkg/exp/template/parse.go
+++ b/src/pkg/exp/template/parse.go
@@ -539,8 +539,8 @@ func (t *Template) atEOF() bool {
        return false
 }
 
-// Parse parses the template definition string to construct an internal representation
-// of the template for execution.
+// Parse parses the template definition string to construct an internal
+// representation of the template for execution.
 func (t *Template) Parse(s string) (err os.Error) {
        t.startParse(nil, lex(t.name, s))
        defer t.recover(&err)
@@ -549,8 +549,9 @@ func (t *Template) Parse(s string) (err os.Error) {
        return
 }
 
-// ParseInSet parses the template definition string to construct an internal representation
-// of the template for execution. Function bindings are checked against those in the set.
+// ParseInSet parses the template definition string to construct an internal
+// representation of the template for execution.
+// Function bindings are checked against those in the set.
 func (t *Template) ParseInSet(s string, set *Set) (err os.Error) {
        t.startParse(set, lex(t.name, s))
        defer t.recover(&err)
@@ -559,7 +560,8 @@ func (t *Template) ParseInSet(s string, set *Set) (err os.Error) {
        return
 }
 
-// parse is the helper for Parse. It triggers an error if we expect EOF but don't reach it.
+// parse is the helper for Parse.
+// It triggers an error if we expect EOF but don't reach it.
 func (t *Template) parse(toEOF bool) (next node) {
        t.root, next = t.itemList(true)
        if toEOF && next != nil {

diff --git a/src/pkg/exp/template/set.go b/src/pkg/exp/template/set.go
index 492e270e1297c3ce9c0c41f4f571ef822269bbb7..9e37e7cb2bf3cf40a034a76f0d47fac05fb1e38d 100644 (file)
--- a/src/pkg/exp/template/set.go
+++ b/src/pkg/exp/template/set.go
@@ -81,7 +81,7 @@ func (s *Set) recover(errp *os.Error) {
        return
 }
 
-// Parse parses the file into a set of named templates.
+// Parse parses a string into a set of named templates.
 func (s *Set) Parse(text string) (err os.Error) {
        defer s.recover(&err)
        lex := lex("set", text)