Subversion Repositories openrisc

// 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.

package template

import (
        "fmt"
        "reflect"
        "text/template/parse"
)

// common holds the information shared by related templates.
type common struct {
        tmpl map[string]*Template
        // We use two maps, one for parsing and one for execution.
        // This separation makes the API cleaner since it doesn't
        // expose reflection to the client.
        parseFuncs FuncMap
        execFuncs  map[string]reflect.Value
}

// Template is the representation of a parsed template. The *parse.Tree
// field is exported only for use by html/template and should be treated
// as unexported by all other clients.
type Template struct {
        name string
        *parse.Tree
        *common
        leftDelim  string
        rightDelim string
}

// New allocates a new template with the given name.
func New(name string) *Template {
        return &Template{
                name: name,
        }
}

// Name returns the name of the template.
func (t *Template) Name() string {
        return t.name
}

// New allocates a new template associated with the given one and with the same
// delimiters. The association, which is transitive, allows one template to
// invoke another with a {{template}} action.
func (t *Template) New(name string) *Template {
        t.init()
        return &Template{
                name:       name,
                common:     t.common,
                leftDelim:  t.leftDelim,
                rightDelim: t.rightDelim,
        }
}

func (t *Template) init() {
        if t.common == nil {
                t.common = new(common)
                t.tmpl = make(map[string]*Template)
                t.parseFuncs = make(FuncMap)
                t.execFuncs = make(map[string]reflect.Value)
        }
}

// Clone returns a duplicate of the template, including all associated
// templates. The actual representation is not copied, but the name space of
// associated templates is, so further calls to Parse in the copy will add
// templates to the copy but not to the original. Clone can be used to prepare
// common templates and use them with variant definitions for other templates by
// adding the variants after the clone is made.
func (t *Template) Clone() *Template {
        nt := t.copy(nil)
        nt.init()
        nt.tmpl[t.name] = nt
        for k, v := range t.tmpl {
                if k == t.name { // Already installed.
                        continue
                }
                // The associated templates share nt's common structure.
                tmpl := v.copy(nt.common)
                nt.tmpl[k] = tmpl
        }
        for k, v := range t.parseFuncs {
                nt.parseFuncs[k] = v
        }
        for k, v := range t.execFuncs {
                nt.execFuncs[k] = v
        }
        return nt
}

// copy returns a shallow copy of t, with common set to the argument.
func (t *Template) copy(c *common) *Template {
        nt := New(t.name)
        nt.Tree = t.Tree
        nt.common = c
        nt.leftDelim = t.leftDelim
        nt.rightDelim = t.rightDelim
        return nt
}

// AddParseTree creates a new template with the name and parse tree
// and associates it with t.
func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) {
        if t.tmpl[name] != nil {
                return nil, fmt.Errorf("template: redefinition of template %q", name)
        }
        nt := t.New(name)
        nt.Tree = tree
        t.tmpl[name] = nt
        return nt, nil
}

// Templates returns a slice of the templates associated with t, including t
// itself.
func (t *Template) Templates() []*Template {
        // Return a slice so we don't expose the map.
        m := make([]*Template, 0, len(t.tmpl))
        for _, v := range t.tmpl {
                m = append(m, v)
        }
        return m
}

// Delims sets the action delimiters to the specified strings, to be used in
// subsequent calls to Parse, ParseFiles, or ParseGlob. Nested template
// definitions will inherit the settings. An empty delimiter stands for the
// corresponding default: {{ or }}.
// The return value is the template, so calls can be chained.
func (t *Template) Delims(left, right string) *Template {
        t.leftDelim = left
        t.rightDelim = right
        return t
}

// Funcs adds the elements of the argument map to the template's function map.
// It panics if a value in the map is not a function with appropriate return
// type. However, it is legal to overwrite elements of the map. The return
// value is the template, so calls can be chained.
func (t *Template) Funcs(funcMap FuncMap) *Template {
        t.init()
        addValueFuncs(t.execFuncs, funcMap)
        addFuncs(t.parseFuncs, funcMap)
        return t
}

// Lookup returns the template with the given name that is associated with t,
// or nil if there is no such template.
func (t *Template) Lookup(name string) *Template {
        if t.common == nil {
                return nil
        }
        return t.tmpl[name]
}

// Parse parses a string into a template. Nested template definitions will be
// associated with the top-level template t. Parse may be called multiple times
// to parse definitions of templates to associate with t. It is an error if a
// resulting template is non-empty (contains content other than template
// definitions) and would replace a non-empty template with the same name.
// (In multiple calls to Parse with the same receiver template, only one call
// can contain text other than space, comments, and template definitions.)
func (t *Template) Parse(text string) (*Template, error) {
        t.init()
        trees, err := parse.Parse(t.name, text, t.leftDelim, t.rightDelim, t.parseFuncs, builtins)
        if err != nil {
                return nil, err
        }
        // Add the newly parsed trees, including the one for t, into our common structure.
        for name, tree := range trees {
                // If the name we parsed is the name of this template, overwrite this template.
                // The associate method checks it's not a redefinition.
                tmpl := t
                if name != t.name {
                        tmpl = t.New(name)
                }
                // Even if t == tmpl, we need to install it in the common.tmpl map.
                if err := t.associate(tmpl); err != nil {
                        return nil, err
                }
                tmpl.Tree = tree
                tmpl.leftDelim = t.leftDelim
                tmpl.rightDelim = t.rightDelim
        }
        return t, nil
}

// associate installs the new template into the group of templates associated
// with t. It is an error to reuse a name except to overwrite an empty
// template. The two are already known to share the common structure.
func (t *Template) associate(new *Template) error {
        if new.common != t.common {
                panic("internal error: associate not common")
        }
        name := new.name
        if old := t.tmpl[name]; old != nil {
                oldIsEmpty := parse.IsEmptyTree(old.Root)
                newIsEmpty := new.Tree != nil && parse.IsEmptyTree(new.Root)
                if !oldIsEmpty && !newIsEmpty {
                        return fmt.Errorf("template: redefinition of template %q", name)
                }
                if newIsEmpty {
                        // Whether old is empty or not, new is empty; no reason to replace old.
                        return nil
                }
        }
        t.tmpl[name] = new
        return nil
}