Golang parse.Parse函數代碼示例

// 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 replace, err := t.associate(tmpl, tree); err != nil {
			return nil, err
		} else if replace {
			tmpl.Tree = tree
		}
		tmpl.leftDelim = t.leftDelim
		tmpl.rightDelim = t.rightDelim
	}
	return t, nil
}

func TestAddParseTree(t *testing.T) {
	// Create some templates.
	root, err := New("root").Parse(cloneText1)
	if err != nil {
		t.Fatal(err)
	}
	_, err = root.Parse(cloneText2)
	if err != nil {
		t.Fatal(err)
	}
	// Add a new parse tree.
	tree, err := parse.Parse("cloneText3", cloneText3, "", "", nil, builtins)
	if err != nil {
		t.Fatal(err)
	}
	added, err := root.AddParseTree("c", tree["c"])
	// Execute.
	var b bytes.Buffer
	err = added.ExecuteTemplate(&b, "a", 0)
	if err != nil {
		t.Fatal(err)
	}
	if b.String() != "broot" {
		t.Errorf("expected %q got %q", "broot", b.String())
	}
}

func compileTemplate(name, src string) (string, error) {
	tset, err := parse.Parse(name, src, "{{", "}}", funcStubs)
	if err != nil {
		return "", err
	}
	return tset[name].Root.String(), nil
}

// Issue 7032
func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
	master := "{{define \"master\"}}{{end}}"
	tmpl := New("master")
	tree, err := parse.Parse("master", master, "", "", nil)
	if err != nil {
		t.Fatalf("unexpected parse err: %v", err)
	}
	masterTree := tree["master"]
	tmpl.AddParseTree("master", masterTree) // used to panic
}

func compileTree(text string) *parse.Tree {
	funcs := template.FuncMap{
		topAssetsFuncName:    nop,
		bottomAssetsFuncName: nop,
	}
	treeMap, err := parse.Parse("", text, leftDelim, rightDelim, funcs)
	if err != nil {
		panic(err)
	}
	return treeMap[""]
}

func (t *Template) Parse(s string) (*Template, error) {
	fs := map[string]interface{}{
		"print1": print1,
	}
	m, err := parse.Parse("name", s, "{{", "}}", fs)
	if err != nil {
		return nil, err
	}
	t.Tree = m["name"]
	return t, nil
}

/**
parseText 需要知道第一個 tree 的 kind. 以便添加到 t.
可能會載入新的文件, 產生模板名稱對應的模板尚未載入.
直到全部解析完才會完整載入.
參數 ns 是給 tree 的 uri 命名.
*/
func parseText(t *Template, names map[string]bool,
	kind Kind, ns, text string) error {

	var name string

	trees, err := parse.Parse(ns, text,
		t.leftDelim, t.rightDelim, placeholderFuncs, t.base.funcs)

	if err != nil {
		return err
	}

	rootdir := t.RootDir()
	dir := absPath(ns)

	for from, tree := range trees {

		name = from
		// define 內嵌模板不能有擴展名
		if name != ns {

			if path.Ext(name) != "" {
				return fmt.Errorf(
					"template: extension are not supported on define %q", from)
			}
			name = relToURI(rootdir, dir, name)
		}

		if name == "" {
			return fmt.Errorf("template: is invalid on define %q", from)
		}

		// 需要再次檢查模板是否被載入
		if t.base.Lookup(name).IsValid() {
			return fmt.Errorf(
				"template: redefinition of %q", name)
		}

		tree.Name = name
		tree.ParseName = ns

		err = hackNode(t, names, name, tree.Root, -1, tree.Root)

		if err == nil {
			_, err = t.AddParseTree(kind, tree)
		}

		if err != nil {
			return err
		}
	}
	names[ns] = false
	return nil
}

func main() {
	root := template.Must(template.New("root").Parse(`{{define "a"}} {{.}} {{template "b" }} {{.}} ">{{.}} </a>{{end}}`))
	tree, err := parse.Parse("t", `{{define "b"}}<a href="{{end}}`, "", "", nil, nil)
	if err != nil {
		fmt.Println(err)
	}
	added := template.Must(root.AddParseTree("b", tree["b"]))

	err = added.ExecuteTemplate(os.Stdout, "a", "1>0")
	if err != nil {
		fmt.Println(err)
	}

}

// Parse defines the template by parsing the text. 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.muFuncs.RLock()
	trees, err := parse.Parse(t.name, text, t.leftDelim, t.rightDelim, t.parseFuncs, builtins)
	t.muFuncs.RUnlock()
	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 _, err := t.AddParseTree(name, tree); err != nil {
			return nil, err
		}
	}
	return t, nil
}

func TestAddParseTree(t *testing.T) {
	root := Must(New("root").Parse(`{{define "a"}} {{.}} {{template "b"}} {{.}} "></a>{{end}}`))
	tree, err := parse.Parse("t", `{{define "b"}}<a href="{{end}}`, "", "", nil, nil)
	if err != nil {
		t.Fatal(err)
	}
	added := Must(root.AddParseTree("b", tree["b"]))
	b := new(bytes.Buffer)
	err = added.ExecuteTemplate(b, "a", "1>0")
	if err != nil {
		t.Fatal(err)
	}
	if got, want := b.String(), ` 1&gt;0 <a href=" 1%3e0 "></a>`; got != want {
		t.Errorf("got %q want %q", got, want)
	}
}

// Parse parses a string into a template.
func (ve *ViewEngine) Parse(name, src string) (*ViewEngine, error) {
	name = normalizeName(name)

	ve.mu.Lock()
	defer ve.mu.Unlock()

	// Error if a template by this name has already been added.
	_, ok := ve.pages[name]
	if ok || ve.partials.Lookup(name) != nil {
		return ve, fmt.Errorf("viewengine: redefinition of template %q", name)
	}

	trees, err := parse.Parse(name, src, "", "", builtins)
	if err != nil {
		return ve, err
	}

	isPage := false

	// If any of the templates start with the contentSectionPrefix
	// then the template set is treated as a page.
	for _, v := range trees {
		if strings.HasPrefix(v.Name, contentSectionPrefix) {
			isPage = true
			break
		}
	}

	if isPage {
		log.Printf("viewengine: adding page %q\n", name)
		ve.pages[name] = trees
	} else {
		for _, v := range trees {
			log.Printf("viewengine: adding partial %q\n", v.Name)
			_, err := ve.partials.AddParseTree(v.Name, v)
			if err != nil {
				return ve, err
			}
		}
	}

	return ve, nil
}

// Parse parses the given text as a set of template trees, adding placeholders
// for undefined functions and variables.
func Parse(name string, text string) (map[string]*parse.Tree, error) {
	text = ReplaceVariableShorthands(text, '@', "")
	funcs := make(map[string]interface{})
	var treeSet map[string]*parse.Tree
	var err error
	for {
		treeSet, err = parse.Parse(name, text, leftDelim, rightDelim, funcs)
		if err != nil {
			if m := funcNotDefinedRe.FindStringSubmatch(err.Error()); m != nil {
				funcs[m[1]] = func() {}
				continue
			}
			if m := varNotDefinedRe.FindStringSubmatch(err.Error()); m != nil {
				prepend := fmt.Sprintf("{{ $%s := . }}\n", m[1])
				text = prepend + defineRe.ReplaceAllString(text, "$0"+strings.Replace(prepend, "$", "$$", -1))
				continue
			}
			return nil, err
		}
		break
	}
	return treeSet, nil
}

func (t *Template) load(name string, included bool, from string) error {
	for _, v := range t.loaded {
		if v == name {
			return nil
		}
	}
	s, err := t.loadText(name)
	if err != nil {
		return err
	}
	matches := commentRe.FindStringSubmatch(s)
	comment := ""
	if matches != nil && len(matches) > 0 {
		comment = matches[1]
	}
	// Add it to the loaded list before calling parseComment, since
	// it's the path which can trigger additional loads.
	t.loaded = append(t.loaded, name)
	err = t.parseComment(name, comment, name, included)
	if err != nil {
		return err
	}
	if idx := strings.Index(s, "</head>"); idx >= 0 {
		s = s[:idx] + fmt.Sprintf("{{ template %q . }}", topBoilerplateName) + s[idx:]
	}
	if idx := strings.Index(s, "</body>"); idx >= 0 {
		s = s[:idx] + fmt.Sprintf("{{ template %q . }}", bottomBoilerplateName) + s[idx:]
	}
	// Replace {{ block }} with {{ template }} + {{ define }}
	s, err = replaceBlocks(name, s)
	if err != nil {
		return err
	}
	// The $Vars definition must be present at parse
	// time, because otherwise the parser will throw an
	// error when it finds a variable which wasn't
	// previously defined
	// Prepend to the template and to any define nodes found
	s = templatePrepend + defineRe.ReplaceAllString(s, "$0"+strings.Replace(templatePrepend, "$", "$$", -1))
	// Replace @variable shorthands
	s = templateutil.ReplaceVariableShorthands(s, '@', varsKey)
	var fns map[string]interface{}
	if t.funcMap != nil {
		fns = t.funcMap.asTemplateFuncMap()
	}
	var treeMap map[string]*parse.Tree
	fixed := make(map[string]bool)
	for {
		treeMap, err = parse.Parse(name, s, leftDelim, rightDelim, templateFuncs.asTemplateFuncMap(), fns)
		if err == nil {
			break
		}
		if m := undefinedVariableRe.FindStringSubmatch(err.Error()); m != nil && !fixed[err.Error()] {
			fixed[err.Error()] = true
			// Look back to the previous define or beginning of the file
			line, _ := strconv.Atoi(m[1])
			maxP := 0
			// Find the position in s where the error line begins
			for ii := 0; ii < len(s) && line > 1; ii++ {
				maxP++
				if s[ii] == '\n' {
					line--
				}
			}
			varName := m[2]
			// Advance until the variable usage
			if idx := strings.Index(s[maxP:], "$"+varName); idx > 0 {
				maxP += idx
			}
			p := 0
			// Check if we have any defines before the error line
			dm := defineRe.FindAllStringIndex(s, -1)
			for ii := len(dm) - 1; ii >= 0; ii-- {
				v := dm[ii]
				if v[1] < maxP {
					p = v[1]
					break
				}
			}
			s = s[:p] + fmt.Sprintf("{{ $%s := %s }}", varName, varNop) + s[p:]
			err = nil
		}
		if err != nil {
			return fmt.Errorf("error parsing %s", err)
		}
	}
	if err := t.replaceExtendTag(name, treeMap, from); err != nil {
		return err
	}
	var renames map[string]string
	for k, v := range treeMap {
		if _, contains := t.trees[k]; contains {
			log.Debugf("Template %s redefined", k)
			// Redefinition of a template, which is allowed
			// by gondola templates. Just rename this
			// template and change any template
			// nodes referring to it in the final sweep
			if renames == nil {
				renames = make(map[string]string)
			}
//.........這裏部分代碼省略.........

func main() {

	// TODO: MountDir() method takes a directory path
	//       and does a ParseGlob() on it.
	//       Templates loaded from the dir have their names
	//       shortened to just the relative path.
	//       Ex. MountDir("/path/to/dir") might add a template "blah.gohtml"
	//       rather than "/path/to/dir/blah.gohtml".

	// TODO: NoCache = true; should cause ParseGlob, ParseFiles, and MountDir
	//       to always reread the template from disk when executing it.
	//       Basically, the calls to those parse methods cause
	//       the file names to be cached and if NoCache == true then
	//       Execute() reloads the template set from scratch.

	/*
		Goal is to load all view files into a single
		template set and transparently handle any
		master page content area naming collisions across pages.
	*/

	var err error
	var masterPageTemplates []string
	var tmpl = template.New("~")

	// Parse an empty template to avoid panics due
	// to an uninitialized internal parse tree.
	// https://groups.google.com/forum/#!topic/golang-nuts/C8jPINo8sHc
	_, _ = tmpl.Parse("")

	filenames, err := filepath.Glob("./test_views/views/simple/*.gohtml")
	if err != nil {
		panic(err)
	}

	for _, filename := range filenames {
		fmt.Printf("file: %s\n", filename)

		// Read file.
		srcBytes, err := ioutil.ReadFile(filename)
		if err != nil {
			panic(err)
		}
		src := string(srcBytes)

		tree, err := parse.Parse(filename, src, "", "", nil)
		if err != nil {
			panic(err)
		}

		// Iterate all templates defined in the file.
		for _, fileTemplate := range tree {

			// Preprocess page templates.
			// Do nothing to master page templates.
			if !strings.HasSuffix(filename, ".master.gohtml") {
				processPageTemplate(filename, fileTemplate)
			} else {
				// Keep track of which templates were from
				// master page template files.
				masterPageTemplates = append(masterPageTemplates, fileTemplate.Name)
			}

			// Add to our global template set.
			_, err = tmpl.AddParseTree(fileTemplate.Name, fileTemplate)
			if err != nil {
				panic(err)
			}
		}
		fmt.Println()
	}

	// Execute a template as a test.
	var templateName = "test_views/views/simple/page1.gohtml"
	// Clone the template set.
	execTmpl, err := tmpl.Clone()
	if err != nil {
		panic(err)
	}

	// Update the ~ {{template}} calls in all
	// master page templates to have the file name prefix.
	for _, masterPageTemplateName := range masterPageTemplates {
		var execTmplItem = execTmpl.Lookup(masterPageTemplateName)
		prefixTildeTemplates(templateName, execTmplItem.Root.Nodes)
	}

	// *Then* execute the template.
	// We can cache the template set at this point for future renders of this view.
	fmt.Println("*************************")
	var renderedOutput = &bytes.Buffer{}
	err = execTmpl.ExecuteTemplate(renderedOutput, templateName, nil)
	if err != nil {
		panic(err)
	}
	fmt.Print(renderedOutput.String())
	fmt.Println()
	fmt.Println("*************************")
}