// ExecuteTemplate executes a template on the source TeX files. func (t *CompileTask) ExecuteTemplate(templ *template.Template, data interface{}, inputFilename string, outputFilename string) { sc := t.context() useTempFile := outputFilename == "" if useTempFile { outputFilename = sc.MustGetTempFile().Name() } inputFilename = sc.AbsPath(t.defaultCompileFilename(inputFilename)) f, err := os.Create(sc.AbsPath(outputFilename)) if err != nil { panic(err) } w := io.Writer(f) err = templ.ExecuteTemplate(w, filepath.Base(inputFilename), data) if err != nil { panic(err) } f.Close() if useTempFile { // copy back, remove temp err = os.Remove(inputFilename) if err != nil { panic(err) } err = sc.CopyFile(outputFilename, inputFilename) if err != nil { panic(err) } } }
func diffOutput(got string, wantTmpl *template.Template) (string, error) { got = filepath.ToSlash(got) wantBuf := new(bytes.Buffer) data := outputData{ NDK: ndkVersion, GOOS: goos, GOARCH: goarch, GOPATH: gopath, NDKARCH: ndkarch, BuildScript: unixBuildScript, } if goos == "windows" { data.EXE = ".exe" data.BuildScript = windowsBuildScript } if err := wantTmpl.Execute(wantBuf, data); err != nil { return "", err } want := wantBuf.String() if got != want { return diff(got, want) } return "", nil }
func processFile(fc FileConfig, t *template.Template) { // in file iFile, err := os.Open(fc.Name) if err != nil { panic("Can't open " + fc.Name) } defer iFile.Close() // out file oFile, err := os.Create(fc.Name + "_out.txt") if err != nil { panic("Can't open/write to " + fc.Name + "_out.txt") } defer oFile.Close() r := csv.NewReader(iFile) r.Comma = '\t' r.TrailingComma = true record, err := r.Read() for i := 0; err == nil; record, err = r.Read() { if i == 0 { t.ExecuteTemplate(oFile, fc.TemplateName+"_H", makeTemplateContext(&record)) } i = i + 1 if i <= fc.Skip { continue } oFile.Write([]byte("\n")) t.ExecuteTemplate(oFile, fc.TemplateName, makeTemplateContext(&record)) } fmt.Println(err) oFile.Sync() }
func (r Renderer) RenderPost(pc *PostContext, templates *template.Template) error { err := os.MkdirAll(path.Join(r.OutputPath, pc.Slug), 0755) if err != nil { log.Panicf(err.Error()) } outfile, err := os.Create(path.Join(r.OutputPath, pc.Slug, "index.html")) if err != nil { log.Panicf(err.Error()) } err = templates.ExecuteTemplate(outfile, "post.html", pc) if err != nil { log.Panicf(err.Error()) } // copy images log.Printf("\"%s\": Using %d %s", pc.Slug, len(pc.Images), pluralize("image", len(pc.Images))) for _, image := range pc.Images { err = cp(image.SrcAbsPath, path.Join(r.OutputPath, pc.Slug, image.Filename)) if err != nil { log.Panicf(err.Error()) } } log.Printf("\"%s\": Done rendering", pc.Slug) return nil }
func applyTemplate(t *template.Template, name string, data interface{}) []byte { var buf bytes.Buffer if err := t.Execute(&buf, data); err != nil { log.Printf("%s.Execute: %s", name, err) } return buf.Bytes() }
// execute runs the given go-template over the given context. func (temp *Templater) Execute(name string, templateStr string, context interface{}) string { var parsed *template.Template = nil // Check the cache. cached, isCached := temp.templateCache.Get(templateStr) if !isCached { t := template.New(name) parsedTemplate, err := t.Parse(templateStr) if err != nil { panic(err) } temp.templateCache.Set(templateStr, parsedTemplate) parsed = parsedTemplate } else { parsed = cached.(*template.Template) } // Execute the template. var source bytes.Buffer eerr := parsed.Execute(&source, context) if eerr != nil { panic(eerr) } return source.String() }
func (g *Generator) generatePerModelFiles(templateFileNames []string, modelTpls *template.Template, modelsDir string, filter func(modelInfo *modelInfo) bool) error { for _, tplFileName := range templateFileNames { tplName := filepath.Base(tplFileName) // Apply the templates to each model in the API for _, modelInfo := range g.modelsInfo { if filter(modelInfo) { continue } // TODO: Do this concurrently repl := strings.NewReplacer( templateExt, "", fileNameModelNameInterpolation, modelInfo.Name, fileNameAPINameInterpolation, g.config.APIName, fileNameAPIPrefixInterpolation, g.config.APIPrefix, ) fileName := repl.Replace(tplName) err := generateFile(path.Join(modelsDir, fileName), modelTpls.Lookup(tplName), templateData{ Config: g.config, API: g.api, CurrentModelInfo: modelInfo, AllModelsInfo: g.modelsInfo, AuthInfo: g.authInfo, CurrentTime: time.Now(), }) if err != nil { return errors.Annotatef(err, "when generating model or service %q", modelInfo.Name) } } } return nil }
// templateWorker create file from template // done channel send nil or error back func templateWorker(tpl *template.Template, ftpl FileTemplates, done chan error) { // check file template path ok, err := utils.PathExists(ftpl.Path) if err != nil { done <- err return } // file template path not exists, create new file template path if !ok { if err := os.MkdirAll(ftpl.Path, 0755); err != nil { done <- err return } } // create new target file f, err := os.OpenFile(filepath.Join(ftpl.Path, ftpl.Target), os.O_WRONLY|os.O_CREATE, 0755) if err != nil { done <- err return } defer f.Close() // generate file content, // send return to channel (nil or err) done <- tpl.ExecuteTemplate(f, ftpl.Tpl, ftpl.Vars) }
func (c *Config) writePlaylist(mount, ext string, t *template.Template) error { for i, s := range c.Server { if s.Kind == "master" { continue } url := fmt.Sprintf("%s%s", c.ServerURL(s), mount) servers := []string{url} for j, s := range c.Server { if s.Kind == "master" || i == j { continue } url := fmt.Sprintf("%s%s", c.ServerURL(s), mount) servers = append(servers, url) } name := fmt.Sprintf("%s-%s.%s", mount, s.Name, ext) f, err := os.Create(name) if err != nil { return err } if err := t.Execute(f, servers); err != nil { return err } f.Close() } return nil }
func executeTemplate(tmpl *template.Template, data interface{}) (string, error) { var cmdBuffer bytes.Buffer if err := tmpl.Execute(&cmdBuffer, data); err != nil { return "", err } return cmdBuffer.String(), nil }
// respond responds to a request by executing the html template t with data. func Respond(w http.ResponseWriter, t *template.Template, data interface{}) { fmt.Println("Respond") w.Header().Set("Content-Type", "text/html; charset=utf-8") if err := t.Execute(w, data); err != nil { log.Print(err) } }
func waitForWatcher(ctx context.Context, watcher *inotify.Watcher, match matcherFunc, tpl *template.Template, monitor bool) { defer watcher.Close() for { select { case <-ctx.Done(): // Timeout os.Exit(2) return case ev := <-watcher.Event: if !match(ev) { break } if tpl != nil { tpl.Execute(os.Stdout, ev) log.Infoln() } else { log.Infoln(ev) } // Finish if not monitoring mode. if !monitor { return } case err := <-watcher.Error: log.Fatal(err) } } }
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 (blankPanel blankPanel) generate(terminal, packageName string, employee Employee) []byte { var t *template.Template var buf bytes.Buffer t = template.New("blankpanel.html") t, err := t.ParseFiles("../lessgo/template/component/" + terminal + "/blankpanel.html") if err != nil { Log.Error(err.Error()) return []byte{} } data := make(map[string]interface{}) data["BlankPanel"] = blankPanel data["Terminal"] = terminal data["Employee"] = employee err = t.Execute(&buf, data) if err != nil { Log.Error(err.Error()) return []byte{} } return buf.Bytes() }
func WriteTemplate(temp *template.Template, out string, data interface{}) { file, err := os.Create(path.Clean(out)) defer file.Close() HandleError(err) HandleError(temp.Execute(file, data)) }
func exportTileset(filename string, tmpl *template.Template) { fmt.Printf("Processing %s\n", filename) file, err := os.Open(filename) if err != nil { log.Fatal(err) } tileset, err := tmx.Read(file) if err != nil { log.Fatal(err) } luaFilename := strings.Replace(filepath.Base(filename), filepath.Ext(filename), ".lua", 1) outputPath := filepath.Join(filepath.Dir(filename), luaFilename) output, err := os.Create(outputPath) if err != nil { log.Fatal(err) } err = tmpl.Execute(output, tileset) if err != nil { log.Fatal(err) } }
/* * Render page * * @param pageFilePath (string) * @param w (http.ResponseWriter) * * @return (error) */ func (page *Page) Render(pageFilePath string, w http.ResponseWriter) (err error) { columnFilePath := page.PageSetting.Layout + ".html" mainFilePath := "main.html" contentFilePath := pageFilePath + ".html" sidebarFilePath := "sidebar.html" var tmpl *template.Template switch page.PageSetting.ShowSidebar { case true: tmpl, err = template.ParseFiles( LAYOUT_FOLDER+mainFilePath, LAYOUT_FOLDER+columnFilePath, LAYOUT_FOLDER+sidebarFilePath, STATIC_FOLDER+contentFilePath) case false: tmpl, err = template.ParseFiles( LAYOUT_FOLDER+mainFilePath, LAYOUT_FOLDER+columnFilePath, STATIC_FOLDER+contentFilePath) } if err != nil { return } tmpl.Execute(w, page) return }
func genConfig(appPath string, data map[string]string) error { var src, dest *os.File var fileContent []byte var err error var tmpl *template.Template name := filepath.Join(appPath, "conf", "app.cnf.template") if src, err = os.Open(name); err != nil { return err } tmpfile := name defer func() { src.Close(); os.Remove(tmpfile) }() name = filepath.Join(appPath, "conf", "app.cnf") if dest, err = os.OpenFile(name, os.O_CREATE|os.O_WRONLY, 0666); err != nil { return nil } defer dest.Close() if fileContent, err = ioutil.ReadAll(src); err != nil { return err } if tmpl, err = template.New("").Parse(string(fileContent)); err != nil { return err } return tmpl.Execute(dest, data) }
func generatePage(t *template.Template, data interface{}) ([]byte, error) { buffer := bytes.NewBuffer(nil) if err := t.Execute(buffer, data); err != nil { return nil, err } return buffer.Bytes(), nil }
func Register(templates *template.Template) { // http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { // // Load template according to the requested path, excluding the leading "/" // requestedFile := req.URL.Path[1:] // template := templates.Lookup(requestedFile + ".html") // // var context interface{} = nil // context = viewmodels.Get("My Title", requestedFile) // // if template != nil { // template.Execute(w, context) // } else { // w.WriteHeader(404) // w.Write([]byte("404 - " + http.StatusText(404))) // } // }) ic := new(indexController) ic.template = templates.Lookup("index.html") http.HandleFunc("/index", ic.get) cc := new(categoriesController) cc.template = templates.Lookup("categories.html") http.HandleFunc("/categories", cc.get) // redirect /img/ and /css/ dir to assets/img/ and assets/css/ http.HandleFunc("/img/", serveAssets) http.HandleFunc("/css/", serveAssets) }
// execTmpl executes the provided template on the data, emitting the string. // It presumes that the input data is semantically correct for the template. func execTmpl(t *template.Template, data interface{}) string { var b bytes.Buffer if err := t.Execute(&b, data); err != nil { panic("drum: " + err.Error()) } return b.String() }
func (suite *ExamplesSuite) executeTemplate(tmpl *template.Template) { cqlshCmd := exec.Command("cqlsh") inPipe, inPipeErr := cqlshCmd.StdinPipe() if nil != inPipeErr { panic(inPipeErr.Error()) } if startErr := cqlshCmd.Start(); nil != startErr { panic(startErr.Error()) } data := struct { Keyspace string Id gocql.UUID }{ Keyspace: cassandraConfig.Keyspace, Id: suite.id, } if renderErr := tmpl.Execute(inPipe, data); nil != renderErr { panic(renderErr.Error()) } inPipe.Close() if waitErr := cqlshCmd.Wait(); nil != waitErr { panic(waitErr.Error()) } }
func diffOutput(got string, wantTmpl *template.Template) (string, error) { got = filepath.ToSlash(got) wantBuf := new(bytes.Buffer) data := outputData{ NDK: ndkVersion, GOOS: goos, GOARCH: goarch, GOPATH: gopath, NDKARCH: ndkarch, Xproj: projPbxproj, Xcontents: contentsJSON, Xinfo: infoplistTmplData{Name: "Basic"}, NumCPU: strconv.Itoa(runtime.NumCPU()), } if goos == "windows" { data.EXE = ".exe" } if err := wantTmpl.Execute(wantBuf, data); err != nil { return "", err } want := wantBuf.String() if got != want { return diff(got, want) } return "", nil }
func getServiceURLWithClient(client *unversioned.Client, ip, namespace, service string, t *template.Template) (string, error) { port, err := getServicePort(client, namespace, service) if err != nil { return "", err } var doc bytes.Buffer err = t.Execute(&doc, ipPort{ip, port}) if err != nil { return "", err } u, err := url.Parse(doc.String()) if err != nil { return "", err } annotations, err := getServiceAnnotations(client, namespace, service) if err != nil { return "", err } if scheme, ok := annotations[serviceAPIAnnotationScheme]; ok { u.Scheme = scheme } if path, ok := annotations[serviceAPIAnnotationPath]; ok && len(u.Path) == 0 { u.Path = path } return u.String(), nil }
// write writes the configuration file, will write to stdout if dryRun == true func (cfg *loadBalancerConfig) write(services map[string][]service, dryRun bool) (err error) { var w io.Writer if dryRun { w = os.Stdout } else { w, err = os.Create(cfg.Config) if err != nil { return } } var t *template.Template t, err = template.ParseFiles(cfg.Template) if err != nil { return } conf := make(map[string]interface{}) conf["startSyslog"] = strconv.FormatBool(cfg.startSyslog) conf["services"] = services // default load balancer algorithm is roundrobin conf["defLbAlgorithm"] = lbDefAlgorithm if cfg.lbDefAlgorithm != "" { conf["defLbAlgorithm"] = cfg.lbDefAlgorithm } err = t.Execute(w, conf) return }
func RunTemplate(reportFilename, templateFile, templateText string, out *os.File, data interface{}, format string) (err error) { var tmpl *template.Template var htmpl *htemplate.Template if templateFile != "" { if format == "html" { htmpl, err = htemplate.New(templateFile).ParseGlob(templateFile) } else { tmpl, err = template.New(templateFile).ParseGlob(templateFile) } } else { if format == "html" { htmpl, err = htemplate.New(reportFilename).Parse(templateText) } else { tmpl, err = template.New(reportFilename).Parse(templateText) } } if err != nil { return err } if format == "html" { err = htmpl.Execute(out, data) } else { err = tmpl.Execute(out, data) } if err != nil { return err } return err }
func prepTemplate(parent *template.Template, fn, base string) error { t := parent.New(base) f, err := os.Open(fn) if err != nil { return err } defer f.Close() msg, err := mail.ReadMessage(f) if err != nil { return err } for k, v := range defaultHeaders { if msg.Header.Get(k) == "" { msg.Header[k] = v } } data := &bytes.Buffer{} // This is the only place I could find this method. :/ http.Header(msg.Header).Write(data) data.Write([]byte{'\r', '\n'}) _, err = io.Copy(data, msg.Body) if err != nil { return err } _, err = t.Parse(data.String()) return err }
func generateCode(outputFile string, tmpl *template.Template, pkg string, parsed *parser.Thrift) error { wrappedServices, err := wrapServices(parsed) if err != nil { log.Fatalf("Service parsing error: %v", err) } buf := &bytes.Buffer{} td := TemplateData{ Package: pkg, Services: wrappedServices, ThriftImport: *apacheThriftImport, TChannelImport: tchannelThriftImport, } if err := tmpl.Execute(buf, td); err != nil { return fmt.Errorf("failed to execute template: %v", err) } generated := cleanGeneratedCode(buf.Bytes()) if err := ioutil.WriteFile(outputFile, generated, 0666); err != nil { return fmt.Errorf("cannot write output file %s: %v", outputFile, err) } // Run gofmt on the file (ignore any errors) exec.Command("gofmt", "-w", outputFile).Run() return nil }
func makeTemplates(t *[]TemplateConfig) (*template.Template, error) { var textTemplates *template.Template var err error templateFuncs := template.FuncMap{"padBefore": PadBefore} for i, templateConfig := range *t { t := "" h := "" for i, l := range templateConfig.Lines { if i > 0 { t = t + "\t" h = h + "\t" } t = t + l.Value h = h + l.Header } // Template proper if i == 0 { textTemplates, err = template.New(templateConfig.Name).Funcs(templateFuncs).Parse(t) } else { textTemplates, err = textTemplates.New(templateConfig.Name).Funcs(templateFuncs).Parse(t) } // Template header textTemplates, err = textTemplates.New(templateConfig.Name + "_H").Funcs(templateFuncs).Parse(h) if err != nil { break } } return textTemplates, err }
// ShowMessage opens a message dialog to show the user a message. func (w *Workflow) ShowMessage(message string) (err error) { script := `tell application "Alfred {{.Version}}" activate set alfredPath to (path to application "Alfred {{.Version}}") set alfredIcon to path to resource "appicon.icns" in bundle (alfredPath as alias) display dialog "{{.Prompt}}" with title "{{.Title}}" buttons {"Ok"} default button "Ok" with icon alfredIcon end tell` data := struct { Version string Prompt string Title string }{os.Getenv("alfred_short_version"), message, w.name} var tmpl *template.Template tmpl, err = template.New("script").Parse(script) if err != nil { return } var buf bytes.Buffer err = tmpl.Execute(&buf, data) if err != nil { return } script = buf.String() _, err = RunScript(script) return }