func writeTmpl(tmpl *template.Template, vmConfigs []vm) { file, err := os.Create(tmpl.Name()) checkError(err) defer file.Close() err = tmpl.Execute(file, vmConfigs) checkError(err) }
func (t *Repository) addDependencies(templ *template.Template) (*template.Template, error) { name := templ.Name() deps := t.flattenDependencies(templ, nil) for dep := range deps { if dep == "" { continue } tt := templ.Lookup(dep) // Check if we have it if tt == nil { tt = t.templates[dep] // Still dont have it return an error if tt == nil { return templ, fmt.Errorf("Could not find template %s", dep) } var err error // Add it to the parse tree templ, err = templ.AddParseTree(dep, tt.Tree) if err != nil { return templ, fmt.Errorf("Dependency Error: %v", err) } } } return templ.Lookup(name), nil }
func parseEventListenerTemplates() { var templ *template.Template eventListenersStore = make(map[string]*template.Template) templ = template.Must(template.New("clickEventListener").Parse(clickEventListenerTpl)) eventListenersStore[templ.Name()] = templ templ = template.Must(template.New("submitEventListener").Parse(submitEventListenerTpl)) eventListenersStore[templ.Name()] = templ }
// applyTemplateToResponseWriter uses an http.ResponseWriter as the io.Writer // for the call to template.Execute. It uses an io.Writer wrapper to capture // errors from the underlying http.ResponseWriter. Errors are logged only when // they come from the template processing and not the Writer; this avoid // polluting log files with error messages due to networking issues, such as // client disconnects and http HEAD protocol violations. func applyTemplateToResponseWriter(rw http.ResponseWriter, t *template.Template, data interface{}) { w := &writerCapturesErr{w: rw} err := t.Execute(w, data) // There are some cases where template.Execute does not return an error when // rw returns an error, and some where it does. So check w.err first. if w.err == nil && err != nil { // Log template errors. log.Printf("%s.Execute: %s", t.Name(), err) } }
func (s *server) listHandler(t *template.Template) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if err := t.Execute(w, s); err != nil { log.Printf("error executing template %s: %v", t.Name(), err) w.WriteHeader(500) w.Write([]byte(err.Error())) return } } }
func renderTemplate(w http.ResponseWriter, tmpl *template.Template, data interface{}) error { wr := &writeRecorder{w: w} if err := tmpl.Execute(wr, data); err != nil { if !wr.wrote { // TODO(ericchiang): replace with better internal server error. http.Error(w, "Internal server error", http.StatusInternalServerError) } return fmt.Errorf("Error rendering template %s: %s", tmpl.Name(), err) } return nil }
func renderCode(fullpath string, tmpl *template.Template, context interface{}) (fb []byte, err error) { targetBuf := bytes.Buffer{} err = tmpl.Execute(&targetBuf, context) if err != nil { return nil, fmt.Errorf("Problem rendering %s : %v", tmpl.Name(), err) } fb, err = imports.Process(fullpath, targetBuf.Bytes(), nil) if err != nil { return targetBuf.Bytes(), fmt.Errorf("Problem formatting %s : %v\n%s", tmpl.Name(), err, targetBuf.Bytes()) } return fb, err }
// Parse parses declared templates. func Parse(t *template.Template) (*template.Template, error) { for name, s := range templates { var tmpl *template.Template if t == nil { t = template.New(name) } if name == t.Name() { tmpl = t } else { tmpl = t.New(name) } if _, err := tmpl.Parse(s); err != nil { return nil, err } } return t, nil }
// computeOutCtx takes a template and its start context and computes the output // context while storing any inferences in e. func (e *escaper) computeOutCtx(c context, t *template.Template) context { // Propagate context over the body. c1, ok := e.escapeTemplateBody(c, t) if !ok { // Look for a fixed point by assuming c1 as the output context. if c2, ok2 := e.escapeTemplateBody(c1, t); ok2 { c1, ok = c2, true } // Use c1 as the error context if neither assumption worked. } if !ok && c1.state != stateError { return context{ state: stateError, // TODO: Find the first node with a line in t.text.Tree.Root err: errorf(ErrOutputContext, 0, "cannot compute output context for template %s", t.Name()), } } return c1 }
func lazyInitTemplate() { webPanelTpl = template.New("") var tpl *template.Template // main tpl = template.Must(template.New("main").Parse(_TPL_PAGE_MAIN)) webPanelTpl.AddParseTree(tpl.Name(), tpl.Tree) webPanelBuilder[tpl.Name()] = buildMainPageData // 404 tpl = template.Must(template.New("404").Parse(_TPL_PAGE_404)) webPanelTpl.AddParseTree(tpl.Name(), tpl.Tree) webPanelBuilder[tpl.Name()] = build404PageData }
// escapeTemplateBody escapes the given template assuming the given output // context, and returns the best guess at the output context and whether the // assumption was correct. func (e *escaper) escapeTemplateBody(c context, t *template.Template) (context, bool) { filter := func(e1 *escaper, c1 context) bool { if c1.state == stateError { // Do not update the input escaper, e. return false } if !e1.called[t.Name()] { // If t is not recursively called, then c1 is an // accurate output context. return true } // c1 is accurate if it matches our assumed output context. return c.eq(c1) } // We need to assume an output context so that recursive template calls // take the fast path out of escapeTree instead of infinitely recursing. // Naively assuming that the input context is the same as the output // works >90% of the time. e.output[t.Name()] = c return e.escapeListConditionally(c, t.Tree.Root, filter) }
//Load templates func init() { // Templates = &tst.Trie{} var templ *tpl.Template Templates = make(map[string]*tpl.Template) newTpl = tpl.Must(tpl.New("new.tpl").Parse(newTplString)) Templates[newTpl.Name()] = newTpl editTpl = tpl.Must(tpl.New("edit.tpl").Parse(editTplString)) Templates[editTpl.Name()] = editTpl viewTpl = tpl.Must(tpl.New("view.tpl").Parse(viewTplString)) Templates[viewTpl.Name()] = viewTpl templ = tpl.Must(tpl.New("select.tpl").Parse(selectTplString)) Templates[templ.Name()] = templ templ = tpl.Must(tpl.New("inputText.tpl").Parse(inputTextTplString)) Templates[templ.Name()] = templ templ = tpl.Must(tpl.New("fieldset.tpl").Parse("<fieldset>{{.MAP.Content}}</fieldset>")) Templates[templ.Name()] = templ templ = tpl.Must(tpl.New("message.tpl").Parse(`<li class="{{.TYPE.Type}}">{{.TYPE.Text}}</li>`)) Templates[templ.Name()] = templ templ = tpl.Must(tpl.New("messagePanel.tpl").Parse(`<ul id="message" class="panel no-bullet">{{.MAP.Content}}</ul>`)) Templates[templ.Name()] = templ }
//loadTemplate 加载解析模板 func (d *dynamic) loadTemplate(currDir string) (*template.Template, error) { if len(d.Template) == 0 { return nil, fmt.Errorf(ErrorPageNotTemplate) } var ( t *template.Template = nil filePath, fileName, content string b []byte err error ) for _, filename := range d.Template { filePath = filepath.Join(currDir, filename) fileName = filepath.Base(filename) b, err = ioutil.ReadFile(filePath) if err != nil { return nil, err } content = d.formatTemplate(string(b)) var tmpl *template.Template if t == nil { t = template.New(fileName) } if fileName == t.Name() { tmpl = t } else { tmpl = t.New(fileName) } tmpl.Delims(d.Delims.Left, d.Delims.Right) tmpl.Funcs(TemplateFuncMap) _, err = tmpl.Parse(content) if err != nil { return nil, err } } return t, nil }
// runTemplateCommand executes the given template with the given data, // which generates a command to execute. If exitNonZeroOK is true, no // error is returned if the exit code is not 0, otherwise an error is // returned. func runTemplateCommand(t *template.Template, exitNonZeroOK bool, data interface{}) ( exitCode int, err error, ) { // Clone the template to ensure the original won't be changed. cloned, err := t.Clone() if err != nil { return -1, errors.Annotatef(err, "cannot clone command template %q", t.Name()) } var buf bytes.Buffer if err := cloned.Execute(&buf, data); err != nil { return -1, errors.Annotatef(err, "cannot execute command template %q", t.Name()) } command := buf.String() logger.Debugf("running command %q", command) result, err := exec.RunCommands(exec.RunParams{Commands: command}) if err != nil { return -1, errors.Annotatef(err, "cannot run command %q", command) } exitCode = result.Code stdout := string(result.Stdout) stderr := string(result.Stderr) logger.Debugf( "command %q returned code=%d, stdout=%q, stderr=%q", command, exitCode, stdout, stderr, ) if exitCode != 0 { if exitNonZeroOK { return exitCode, nil } return exitCode, errors.Errorf( "command %q failed with exit code %d", command, exitCode, ) } return 0, nil }
func renderTemplate(t *template.Template, o *renderOption, w io.Writer) error { return t.ExecuteTemplate(w, t.Name(), o) }