exp/template: rename Parse*File and Parse*Files for clarity

IMPORTANT: Previous usage of *Files will continue to compile
fine but misbehave since the interface is compatible.

The following functions have been renamed:

    ParseFiles => ParseGlob
    ParseFile => ParseFiles
    ParseSetFiles => ParseSetGlob
    ParseSetFile => ParseSetFiles
    ParseTemplateFiles => ParseTemplateGlob
    ParseTemplateFile => ParseTemplateFiles

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

diff --git a/src/pkg/exp/template/helper.go b/src/pkg/exp/template/helper.go
index ae6a057eef9886b35c4bd3a76811ed49e3037148..c9b099856517973166bef83fdd34238ea60331cc 100644 (file)
--- a/src/pkg/exp/template/helper.go
+++ b/src/pkg/exp/template/helper.go
@@ -70,7 +70,7 @@ func (t *Template) parseFileInSet(filename string, set *Set) (*Template, os.Erro
 // SetMust is a helper that wraps a call to a function returning (*Set, os.Error)
 // and panics if the error is non-nil. It is intended for use in variable initializations
 // such as
-//     var s = template.SetMust(template.ParseSetFile("file"))
+//     var s = template.SetMust(template.ParseSetFiles("file"))
 func SetMust(s *Set, err os.Error) *Set {
        if err != nil {
                panic(err)
@@ -78,10 +78,10 @@ func SetMust(s *Set, err os.Error) *Set {
        return s
 }
 
-// ParseFile parses the named files into a set of named templates.
+// ParseFiles parses the named files into a set of named templates.
 // Each file must be parseable by itself.
 // If an error occurs, parsing stops and the returned set is nil.
-func (s *Set) ParseFile(filenames ...string) (*Set, os.Error) {
+func (s *Set) ParseFiles(filenames ...string) (*Set, os.Error) {
        for _, filename := range filenames {
                b, err := ioutil.ReadFile(filename)
                if err != nil {
@@ -95,9 +95,9 @@ func (s *Set) ParseFile(filenames ...string) (*Set, os.Error) {
        return s, nil
 }
 
-// ParseSetFile creates a new Set and parses the set definition from the
+// ParseSetFiles creates a new Set and parses the set definition from the
 // named files. Each file must be individually parseable.
-func ParseSetFile(filenames ...string) (*Set, os.Error) {
+func ParseSetFiles(filenames ...string) (*Set, os.Error) {
        s := new(Set)
        for _, filename := range filenames {
                b, err := ioutil.ReadFile(filename)
@@ -112,11 +112,11 @@ func ParseSetFile(filenames ...string) (*Set, os.Error) {
        return s, nil
 }
 
-// ParseFiles parses the set definition from the files identified by the
+// ParseGlob parses the set definition from the files identified by the
 // pattern.  The pattern is processed by filepath.Glob and must match at
 // least one file.
 // If an error occurs, parsing stops and the returned set is nil.
-func (s *Set) ParseFiles(pattern string) (*Set, os.Error) {
+func (s *Set) ParseGlob(pattern string) (*Set, os.Error) {
        filenames, err := filepath.Glob(pattern)
        if err != nil {
                return nil, err
@@ -124,14 +124,14 @@ func (s *Set) ParseFiles(pattern string) (*Set, os.Error) {
        if len(filenames) == 0 {
                return nil, fmt.Errorf("pattern matches no files: %#q", pattern)
        }
-       return s.ParseFile(filenames...)
+       return s.ParseFiles(filenames...)
 }
 
-// ParseSetFiles creates a new Set and parses the set definition from the
+// ParseSetGlob creates a new Set and parses the set definition from the
 // files identified by the pattern. The pattern is processed by filepath.Glob
 // and must match at least one file.
-func ParseSetFiles(pattern string) (*Set, os.Error) {
-       set, err := new(Set).ParseFiles(pattern)
+func ParseSetGlob(pattern string) (*Set, os.Error) {
+       set, err := new(Set).ParseGlob(pattern)
        if err != nil {
                return nil, err
        }
@@ -140,17 +140,17 @@ func ParseSetFiles(pattern string) (*Set, os.Error) {
 
 // Functions and methods to parse stand-alone template files into a set.
 
-// ParseTemplateFile parses the named template files and adds
-// them to the set. Each template will named the base name of
+// ParseTemplateFiles parses the named template files and adds
+// them to the set. Each template will be named the base name of
 // its file.
-// Unlike with ParseFile, each file should be a stand-alone template
+// Unlike with ParseFiles, 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
+// file does not contain {{define}} clauses. ParseTemplateFiles 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.
 // If an error occurs, parsing stops and the returned set is nil.
-func (s *Set) ParseTemplateFile(filenames ...string) (*Set, os.Error) {
+func (s *Set) ParseTemplateFiles(filenames ...string) (*Set, os.Error) {
        for _, filename := range filenames {
                _, err := parseFileInSet(filename, s)
                if err != nil {
@@ -160,17 +160,17 @@ func (s *Set) ParseTemplateFile(filenames ...string) (*Set, os.Error) {
        return s, nil
 }
 
-// ParseTemplateFiles parses the template files matched by the
-// patern and adds them to the set. Each template will named
+// ParseTemplateGlob parses the template files matched by the
+// patern and adds them to the set. Each template will be named
 // the base name of its file.
-// Unlike with ParseFiles, each file should be a stand-alone template
+// Unlike with ParseGlob, 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. ParseTemplateFiles is
+// file does not contain {{define}} clauses. ParseTemplateGlob 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.
 // If an error occurs, parsing stops and the returned set is nil.
-func (s *Set) ParseTemplateFiles(pattern string) (*Set, os.Error) {
+func (s *Set) ParseTemplateGlob(pattern string) (*Set, os.Error) {
        filenames, err := filepath.Glob(pattern)
        if err != nil {
                return nil, err
@@ -184,17 +184,17 @@ func (s *Set) ParseTemplateFiles(pattern string) (*Set, os.Error) {
        return s, nil
 }
 
-// ParseTemplateFile creates a set by parsing the named files,
-// each of which defines a single template. Each template will
+// ParseTemplateFiles creates a set by parsing the named files,
+// each of which defines a single template. Each template will be
 // named the base name of its file.
-// Unlike with ParseFile, each file should be a stand-alone template
+// Unlike with ParseFiles, 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
+// file does not contain {{define}} clauses. ParseTemplateFiles 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 ParseTemplateFile(filenames ...string) (*Set, os.Error) {
+func ParseTemplateFiles(filenames ...string) (*Set, os.Error) {
        set := new(Set)
        set.init()
        for _, filename := range filenames {
@@ -209,17 +209,17 @@ func ParseTemplateFile(filenames ...string) (*Set, os.Error) {
        return set, nil
 }
 
-// ParseTemplateFiles creates a set by parsing the files matched
+// ParseTemplateGlob creates a set by parsing the files matched
 // by the pattern, each of which defines a single template. Each
-// template will named the base name of its file.
-// Unlike with ParseFiles, each file should be a stand-alone template
+// template will be named the base name of its file.
+// Unlike with ParseGlob, 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. ParseTemplateFiles is
+// file does not contain {{define}} clauses. ParseTemplateGlob 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 ParseTemplateFiles(pattern string) (*Set, os.Error) {
+func ParseTemplateGlob(pattern string) (*Set, os.Error) {
        set := new(Set)
        filenames, err := filepath.Glob(pattern)
        if err != nil {

diff --git a/src/pkg/exp/template/set_test.go b/src/pkg/exp/template/set_test.go
index 6fa29063b237f3d8c9880ce28f090d2b8cc7a90e..f437bc779c2c53f9c8c3392b9872cb0eeb388b86 100644 (file)
--- a/src/pkg/exp/template/set_test.go
+++ b/src/pkg/exp/template/set_test.go
@@ -120,58 +120,58 @@ func TestSetExecute(t *testing.T) {
        testExecute(setExecTests, set, t)
 }
 
-func TestSetParseFile(t *testing.T) {
+func TestSetParseFiles(t *testing.T) {
        set := new(Set)
-       _, err := set.ParseFile("DOES NOT EXIST")
+       _, err := set.ParseFiles("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       _, err = set.ParseFile("testdata/file1.tmpl", "testdata/file2.tmpl")
+       _, err = set.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(setExecTests, set, t)
 }
 
-func TestParseSetFile(t *testing.T) {
+func TestParseSetFiles(t *testing.T) {
        set := new(Set)
-       _, err := ParseSetFile("DOES NOT EXIST")
+       _, err := ParseSetFiles("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       set, err = ParseSetFile("testdata/file1.tmpl", "testdata/file2.tmpl")
+       set, err = ParseSetFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(setExecTests, set, t)
 }
 
-func TestSetParseFiles(t *testing.T) {
-       _, err := new(Set).ParseFiles("DOES NOT EXIST")
+func TestSetParseGlob(t *testing.T) {
+       _, err := new(Set).ParseGlob("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       _, err = new(Set).ParseFiles("[x")
+       _, err = new(Set).ParseGlob("[x")
        if err == nil {
                t.Error("expected error for bad pattern; got none")
        }
-       set, err := new(Set).ParseFiles("testdata/file*.tmpl")
+       set, err := new(Set).ParseGlob("testdata/file*.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(setExecTests, set, t)
 }
 
-func TestParseSetFiles(t *testing.T) {
-       _, err := ParseSetFiles("DOES NOT EXIST")
+func TestParseSetGlob(t *testing.T) {
+       _, err := ParseSetGlob("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       _, err = ParseSetFiles("[x")
+       _, err = ParseSetGlob("[x")
        if err == nil {
                t.Error("expected error for bad pattern; got none")
        }
-       set, err := ParseSetFiles("testdata/file*.tmpl")
+       set, err := ParseSetGlob("testdata/file*.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
@@ -182,56 +182,56 @@ var templateFileExecTests = []execTest{
        {"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\ntemplate2\n", 0, true},
 }
 
-func TestSetParseTemplateFile(t *testing.T) {
-       _, err := ParseTemplateFile("DOES NOT EXIST")
+func TestSetParseTemplateFiles(t *testing.T) {
+       _, err := ParseTemplateFiles("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       set, err := new(Set).ParseTemplateFile("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
+       set, err := new(Set).ParseTemplateFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(templateFileExecTests, set, t)
 }
 
-func TestParseTemplateFile(t *testing.T) {
-       _, err := ParseTemplateFile("DOES NOT EXIST")
+func TestParseTemplateFiles(t *testing.T) {
+       _, err := ParseTemplateFiles("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       set, err := new(Set).ParseTemplateFile("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
+       set, err := new(Set).ParseTemplateFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(templateFileExecTests, set, t)
 }
 
-func TestSetParseTemplateFiles(t *testing.T) {
-       _, err := ParseTemplateFiles("DOES NOT EXIST")
+func TestSetParseTemplateGlob(t *testing.T) {
+       _, err := ParseTemplateGlob("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       _, err = new(Set).ParseTemplateFiles("[x")
+       _, err = new(Set).ParseTemplateGlob("[x")
        if err == nil {
                t.Error("expected error for bad pattern; got none")
        }
-       set, err := new(Set).ParseTemplateFiles("testdata/tmpl*.tmpl")
+       set, err := new(Set).ParseTemplateGlob("testdata/tmpl*.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }
        testExecute(templateFileExecTests, set, t)
 }
 
-func TestParseTemplateFiles(t *testing.T) {
-       _, err := ParseTemplateFiles("DOES NOT EXIST")
+func TestParseTemplateGlob(t *testing.T) {
+       _, err := ParseTemplateGlob("DOES NOT EXIST")
        if err == nil {
                t.Error("expected error for non-existent file; got none")
        }
-       _, err = ParseTemplateFiles("[x")
+       _, err = ParseTemplateGlob("[x")
        if err == nil {
                t.Error("expected error for bad pattern; got none")
        }
-       set, err := ParseTemplateFiles("testdata/tmpl*.tmpl")
+       set, err := ParseTemplateGlob("testdata/tmpl*.tmpl")
        if err != nil {
                t.Fatalf("error parsing files: %v", err)
        }