From ad58dc9d26655800694960e71a3458b1a7b665e8 Mon Sep 17 00:00:00 2001 From: Andrew Gerrand Date: Fri, 8 Jul 2011 16:01:32 +1000 Subject: [PATCH] exp/template: the must-have MustParse functions R=r CC=golang-dev https://golang.org/cl/4641096 --- src/pkg/exp/template/Makefile | 1 + src/pkg/exp/template/helper.go | 100 +++++++++++++++++++++++++++++++++ src/pkg/exp/template/parse.go | 12 ++-- src/pkg/exp/template/set.go | 2 +- 4 files changed, 109 insertions(+), 6 deletions(-) create mode 100644 src/pkg/exp/template/helper.go diff --git a/src/pkg/exp/template/Makefile b/src/pkg/exp/template/Makefile index 8550b0d522..988791f354 100644 --- 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 index 0000000000..def4f01f37 --- /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 8b2d602075..2b3cd17aba 100644 --- 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 492e270e12..9e37e7cb2b 100644 --- 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) -- 2.50.0