func init() { var err error fm := template.FuncMap{ "tabs": Tabs, "goify": Goify, "gotyperef": GoTypeRef, "gotypedef": GoTypeDef, "add": Add, "publicizer": Publicizer, "recursivePublicizer": RecursivePublicizer, } if simplePublicizeT, err = template.New("simplePublicize").Funcs(fm).Parse(simplePublicizeTmpl); err != nil { panic(err) } if recursivePublicizeT, err = template.New("recursivePublicize").Funcs(fm).Parse(recursivePublicizeTmpl); err != nil { panic(err) } if objectPublicizeT, err = template.New("objectPublicize").Funcs(fm).Parse(objectPublicizeTmpl); err != nil { panic(err) } if arrayPublicizeT, err = template.New("arrPublicize").Funcs(fm).Parse(arrayPublicizeTmpl); err != nil { panic(err) } if hashPublicizeT, err = template.New("hashPublicize").Funcs(fm).Parse(hashPublicizeTmpl); err != nil { panic(err) } }
// Runs a test case and logs the results. func runTest(t *testing.T, tt *deisTest, cfg *deisTestConfig) { // Fill in the command string template from our test configuration. var cmdBuf bytes.Buffer tmpl := template.Must(template.New("cmd").Parse(tt.cmd)) if err := tmpl.Execute(&cmdBuf, cfg); err != nil { t.Fatal(err) } cmdString := cmdBuf.String() // Change to the target directory if needed. if tt.dir != "" { // Fill in the directory template from our test configuration. var dirBuf bytes.Buffer tmpl := template.Must(template.New("dir").Parse(tt.dir)) if err := tmpl.Execute(&dirBuf, cfg); err != nil { t.Fatal(err) } dir, _ := filepath.Abs(filepath.Join(wd, dirBuf.String())) if err := os.Chdir(dir); err != nil { t.Fatal(err) } } // TODO: Go's testing package doesn't seem to allow for reporting interim // progress--we have to wait until everything completes (or fails) to see // anything that was written with t.Log or t.Fatal. Interim output would // be extremely helpful here, as this takes a while. // Execute the command and log the input and output on error. fmt.Printf("%v ... ", strings.TrimSpace(cmdString)) cmd := exec.Command("sh", "-c", cmdString) if out, err := cmd.Output(); err != nil { t.Fatalf("%v\nOutput:\n%v", err, string(out)) } else { fmt.Println("ok") } }
func render(templName string, templ1Data interface{}, pipelineName string) (io.Reader, error) { templateSrc, err := Asset(templName) if err != nil { return nil, err } // 1st pass templ, err := template.New(templName + "/1").Parse(string(templateSrc)) if err != nil { return nil, err } var firstRender bytes.Buffer err = templ.Execute(&firstRender, templ1Data) if err != nil { return nil, err } // 2nd pass: some properties contain {{ .PipelineName }} templ, err = template.New(templName + "/2").Parse(firstRender.String()) if err != nil { return nil, fmt.Errorf("error rendering template: %s\n\ntemplate content: %s", err, firstRender.String()) } var secondRender bytes.Buffer err = templ.Execute(&secondRender, struct{ PipelineName string }{pipelineName}) return &secondRender, err }
// NewControllersWriter returns a handlers code writer. // Handlers provide the glue between the underlying request data and the user controller. func NewControllersWriter(filename string) (*ControllersWriter, error) { cw := codegen.NewGoGenerator(filename) funcMap := cw.FuncMap funcMap["add"] = func(a, b int) int { return a + b } funcMap["gotypename"] = codegen.GoTypeName ctrlTmpl, err := template.New("controller").Funcs(funcMap).Parse(ctrlT) if err != nil { return nil, err } mountTmpl, err := template.New("mount").Funcs(funcMap).Parse(mountT) if err != nil { return nil, err } unmarshalTmpl, err := template.New("unmarshal").Funcs(funcMap).Parse(unmarshalT) if err != nil { return nil, err } w := ControllersWriter{ GoGenerator: cw, CtrlTmpl: ctrlTmpl, MountTmpl: mountTmpl, UnmarshalTmpl: unmarshalTmpl, } return &w, nil }
func init() { // we see it so it doesn't use a prefix or include a time stamp. stdout = log.New(os.Stdout, "", 0) defaultLog = template.Must(template.New("defaultLog").Parse(defaultLogTmpl)) defaultWord = template.Must(template.New("defaultWord").Parse(defaultWordTmpl)) defaultLine = template.Must(template.New("defaultLine").Parse(defaultLineTmpl)) }
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 init() { globalUsageTemplate = template.Must(template.New("global_usage").Funcs(templFuncs).Parse(` NAME: {{printf "\t%s - %s" .Executable .Description}} USAGE: {{printf "\t%s" .Executable}} [global options] <command> [command options] [arguments...] VERSION: {{printf "\t%s" .Version}} COMMANDS:{{range .Commands}} {{printf "\t%s\t%s" .Name .Summary}}{{end}} GLOBAL OPTIONS:{{range .Flags}} {{printOption .Name .DefValue .Usage}}{{end}} Run "{{.Executable}} help <command>" for more details on a specific command. `[1:])) commandUsageTemplate = template.Must(template.New("command_usage").Funcs(templFuncs).Parse(` NAME: {{printf "\t%s - %s" .Cmd.Name .Cmd.Summary}} USAGE: {{printf "\t%s %s %s" .Executable .Cmd.Name .Cmd.Usage}} DESCRIPTION: {{range $line := descToLines .Cmd.Description}}{{printf "\t%s" $line}} {{end}} {{if .CmdFlags}}OPTIONS:{{range .CmdFlags}} {{printOption .Name .DefValue .Usage}}{{end}} {{end}}For help on global options run "{{.Executable}} help" `[1:])) }
func admin(w http.ResponseWriter, r *http.Request) { /* import template t, _ := template.ParseFiles("../template/shotchart.html") t.Execute(wr io.Writer, p) */ temp := new(Page) values := readDB() buf := new(bytes.Buffer) for _, value := range values { if value.Content == "" { continue } fmt.Println("this is reading from the database the different lines", value) t := template.Must(template.New("form").Parse(form)) t.Execute(buf, value) } fmt.Println("this is the string of template", buf.String()) temp.Form = buf.String() t := template.Must(template.New("page").Parse(adminPage)) t.Execute(w, temp) //t := template.Must(template.New("form").Parse(form)) //t.Execute(w, Tom) //fmt.Println("this is admin page") }
func init() { tmHeader = template.Must(template.New("header").Parse(header)) tmStruct = template.Must(template.New("modelStruct").Parse(modelStruct)) tmObjApi = template.Must(template.New("objApi").Parse(objApi)) tmQueryApi = template.Must(template.New("queryApi").Parse(queryApi)) tmManagedObjApi = template.Must(template.New("managedApi").Parse(managedApi)) }
//----------------------------------------------------------------------------- // Check //----------------------------------------------------------------------------- func TestTextTemplate(t *testing.T) { //t.Skip("skipping TestTextTemplate") teachers := getTeathers() //normal for i, td := range tmpleTests { fmt.Printf("[%d] name:%s\n", i+1, td.tmplName) tmpl, err := tt.New(td.tmplName).Parse(td.tmplString) if err != nil { t.Fatalf("[%d] template.New(%s) error: %s", i+1, td.tmplName, err) } err = tmpl.Execute(os.Stdout, teachers) if err != nil { t.Fatalf("[%d] template.Execute(%s) error: %s", i+1, td.tmplName, err) } } //with func for i, td := range tmpleTests2 { tmpl, err := tt.New("td.tmplName").Funcs(tt.FuncMap{"plus10": plus10}).Parse(td.tmplString) if err != nil { t.Fatalf("[%d] template.New(%s) error: %s", i+1, td.tmplName, err) } err = tmpl.Execute(os.Stdout, teachers) if err != nil { t.Fatalf("[%d] template.Execute(%s) error: %s", i+1, td.tmplName, err) } } }
func (n *NatsClient) PrepareJob(jobName string) { templateID, sha1, err := n.uploadJob(jobName) Expect(err).NotTo(HaveOccurred()) prepareTemplateConfig := PrepareTemplateConfig{ JobName: jobName, TemplateBlobstoreID: templateID, RenderedTemplatesArchiveBlobstoreID: templateID, RenderedTemplatesArchiveSHA1: sha1, ReplyTo: senderID, } buffer := bytes.NewBuffer([]byte{}) t := template.Must(template.New("prepare").Parse(prepareTemplate)) err = t.Execute(buffer, prepareTemplateConfig) Expect(err).NotTo(HaveOccurred()) prepareResponse, err := n.SendMessage(buffer.String()) Expect(err).NotTo(HaveOccurred()) _, err = n.WaitForTask(prepareResponse["value"]["agent_task_id"], -1) Expect(err).ToNot(HaveOccurred()) buffer.Reset() t = template.Must(template.New("apply").Parse(applyTemplate)) err = t.Execute(buffer, prepareTemplateConfig) Expect(err).NotTo(HaveOccurred()) applyResponse, err := n.SendMessage(buffer.String()) Expect(err).NotTo(HaveOccurred()) _, err = n.WaitForTask(applyResponse["value"]["agent_task_id"], -1) Expect(err).ToNot(HaveOccurred()) }
// NewHipchatHandler creates a new by reading the environment func NewHipchatHandler() *HipchatHandler { alertTemplate := os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_ALERT_TEMPLATE") if alertTemplate == "" { alertTemplate = `Severity {{.Severity}} alert triggered by {{.CheckName}} ({{.MetricName}}: {{.Value}}). {{.URL}}` } recoveryTemplate := os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_RECOVERY_TEMPLATE") if recoveryTemplate == "" { recoveryTemplate = `Recovery of {{.CheckName}} ({{.MetricName}}: {{.Value}}). {{.URL}}` } hh := &HipchatHandler{ HipchatClient: &hipchat.Client{AuthToken: os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_API_TOKEN")}, AlertTemplate: template.Must(template.New("alert").Parse(alertTemplate)), RecoveryTemplate: template.Must(template.New("recovery").Parse(recoveryTemplate)), AlertColor: os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_ALERT_COLOR"), RecoveryColor: os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_RECOVERY_COLOR"), From: os.Getenv("CIRCONUS_WEBHOOK_PROXY_HIPCHAT_FROM"), } if hh.AlertColor == "" { hh.AlertColor = hipchat.ColorRed } if hh.RecoveryColor == "" { hh.RecoveryColor = hipchat.ColorGreen } if hh.From == "" { hh.From = "Circonus" } return hh }
func loadTemplates() { templateBox := rice.MustFindBox("templates") layout, err := templateBox.String("layout.html") if err != nil { log.Fatal(err) } t := []string{ "index", "article", "archive", } for _, tplName := range t { tplContent, err := templateBox.String(tplName + ".html") if err != nil { log.Fatal(err) } templates[tplName] = template.Must(template.New("layout").Parse(layout + tplContent)) } feed, err := templateBox.String("feed.atom") if err != nil { log.Fatal(err) } templates["feed.atom"] = template.Must(template.New("feed.atom").Parse(feed)) sitemap, err := templateBox.String("sitemap.xml") if err != nil { log.Fatal(err) } templates["sitemap.xml"] = template.Must(template.New("sitemap.xml").Parse(sitemap)) }
// New allocates a new TvRenamer with the given language, formatting, path and regexp func New(language string, nameFormatting string, newPath string, regex string, move bool) *TvRenamer { var err error tvr := TvRenamer{ Language: language, Move: move, } tvr.NameFormatting, err = template.New("Filename formatting").Parse(nameFormatting) if err != nil { log.Fatal(err) } tvr.NewPath, err = template.New("Path formatting").Parse(newPath) if err != nil { log.Fatal(err) } tvr.Regex, err = regexp.Compile(regex) if err != nil { log.Fatal(err) } return &tvr }
func printRegistryService(name string, port int) error { sTemplate, err := template.New("registry").Parse(registryTemplateString) if err != nil { return err } aTemplate, err := template.New("announce").Parse(announceTemplateString) if err != nil { return err } config := new(service) config.Name = name config.Port = port server, err := os.Create(fmt.Sprintf("%s/%s.service", outPath, config.Name)) if err != nil { return err } announce, err := os.Create(fmt.Sprintf("%s/announce-%s.service", outPath, config.Name)) if err != nil { return err } err = sTemplate.Execute(server, config) if err != nil { return err } return aTemplate.Execute(announce, config) }
func GenerateApi(model *ModelDescriptor) error { t := template.Must(template.New("model").Parse(templates.AppxModel)) output := model.Pkg + "/appx_model_" + model.Name + ".go" f, err := os.Create(output) if err != nil { return err } defer f.Close() if err := t.Execute(f, model); err != nil { return err } t = template.Must(template.New("repo").Funcs(templates.FuncMap).Parse(templates.AppxRepository)) output = model.Pkg + "/appx_model_" + model.Name + "_repository.go" f, err = os.Create(output) if err != nil { return err } defer f.Close() if err := t.Execute(f, model); err != nil { return err } log.Println("[API] generated for model", model.Name) return nil }
func main() { t, _ := template.New("test").Parse("{{with `hello`}}{{.}}{{end}}!\n") t.Execute(os.Stdout, nil) t1, _ := template.New("test").Parse("{{with `hello`}}{{.}} {{with `Mary`}}{{.}}{{end}}{{end}}!\n") //when nested, the dot takes the value according to closest scope t1.Execute(os.Stdout, nil) }
func (g *renderer) Render(input bftinput.Input, manifestPath string, cloudConfigPath string) error { deploymentTemplate := template.Must(template.New("deployment").Parse(DeploymentTemplate)) buffer := bytes.NewBuffer([]byte{}) err := deploymentTemplate.Execute(buffer, input) if err != nil { return bosherr.WrapErrorf(err, "Generating deployment manifest") } err = g.fs.WriteFile(manifestPath, buffer.Bytes()) if err != nil { return bosherr.WrapErrorf(err, "Saving generated manifest") } cloudTemplate := template.Must(template.New("cloud-config").Parse(CloudTemplate)) buffer = bytes.NewBuffer([]byte{}) err = cloudTemplate.Execute(buffer, input) if err != nil { return bosherr.WrapErrorf(err, "Generating cloud config") } err = g.fs.WriteFile(cloudConfigPath, buffer.Bytes()) if err != nil { return bosherr.WrapErrorf(err, "Saving generated cloud config") } return nil }
func (net centosNetManager) writeNetworkInterfaces(dhcpInterfaceConfigurations []DHCPInterfaceConfiguration, staticInterfaceConfigurations []StaticInterfaceConfiguration, dnsServers []string) (bool, error) { anyInterfaceChanged := false staticConfig := centosStaticIfcfg{} staticConfig.DNSServers = newDNSConfigs(dnsServers) staticTemplate := template.Must(template.New("ifcfg").Parse(centosStaticIfcfgTemplate)) for i := range staticInterfaceConfigurations { staticConfig.StaticInterfaceConfiguration = &staticInterfaceConfigurations[i] changed, err := net.writeIfcfgFile(staticConfig.StaticInterfaceConfiguration.Name, staticTemplate, staticConfig) if err != nil { return false, bosherr.WrapError(err, "Writing static config") } anyInterfaceChanged = anyInterfaceChanged || changed } dhcpTemplate := template.Must(template.New("ifcfg").Parse(centosDHCPIfcfgTemplate)) for i := range dhcpInterfaceConfigurations { config := &dhcpInterfaceConfigurations[i] changed, err := net.writeIfcfgFile(config.Name, dhcpTemplate, config) if err != nil { return false, bosherr.WrapError(err, "Writing dhcp config") } anyInterfaceChanged = anyInterfaceChanged || changed } return anyInterfaceChanged, nil }
func main() { if len(os.Args) > 1 { if os.Args[1] == "test" { top := template.Must(template.New("top").Parse(NewTestTopTemplate())) out(top, nil) types := NewTypes() t := template.Must(template.New("types").Parse(NewTestTypeTemplate())) for _, typ := range types { out(t, typ) } return } } top := template.Must(template.New("top").Parse(NewTopTemplate())) out(top, nil) types := NewTypes() t := template.Must(template.New("types").Parse(NewTypeTemplate())) for _, typ := range types { if typ.packed { out(t, typ) } typ.packed = false out(t, typ) } }
func init() { bv, _ := Asset("templates/server/parameter.gotmpl") parameterTemplate = template.Must(template.New("parameter").Parse(string(bv))) bm, _ := Asset("templates/server/operation.gotmpl") operationTemplate = template.Must(template.New("operation").Parse(string(bm))) }
func main() { type Inventory struct { Material string Count uint } sweaters := Inventory{"wool", 17} tmpl, err := template.New("test").Parse("1.{{.Count}} items are made of {{.Material}}\n") if err != nil { panic(err) } err = tmpl.Execute(os.Stdout, sweaters) if err != nil { panic(err) } t, err := template.New("foo").Parse(`2. {{define "T"}}Hello, {{.}}!{{end}}\n`) if err != nil { log.Fatalf("parse err", err) return } out := os.Stdout err = t.ExecuteTemplate(out, "T", "3. <script>alert('you have been pwned')</script>\n") if err != nil { log.Fatalf("parse err", err) return } }
// Runs a test case and logs the results. func runTest(t *testing.T, tt *deisTest, cfg *utils.DeisTestConfig) { // Fill in the command string template from our test configuration. var cmdBuf bytes.Buffer tmpl := template.Must(template.New("cmd").Parse(tt.cmd)) if err := tmpl.Execute(&cmdBuf, cfg); err != nil { t.Fatal(err) } cmdString := cmdBuf.String() // Change to the target directory if needed. if tt.dir != "" { // Fill in the directory template from our test configuration. var dirBuf bytes.Buffer tmpl := template.Must(template.New("dir").Parse(tt.dir)) if err := tmpl.Execute(&dirBuf, cfg); err != nil { t.Fatal(err) } dir, _ := filepath.Abs(filepath.Join(wd, dirBuf.String())) if err := os.Chdir(dir); err != nil { t.Fatal(err) } } // Execute the command and log the input and output on error. fmt.Printf("%v ... ", strings.TrimSpace(cmdString)) cmd := exec.Command("sh", "-c", cmdString) if out, err := cmd.Output(); err != nil { t.Fatalf("%v\nOutput:\n%v", err, string(out)) } else { fmt.Println("ok") } }
func Render(w http.ResponseWriter, settings *RenderSettings) { root_tpl := tt.Must(tt.New("rtt").Parse(settings.RootTemplate)) repo_tpl := tt.Must(tt.New("rpt").Parse(settings.RepositoryTemplate)) root_buf := new(bytes.Buffer) err := root_tpl.Execute(root_buf, settings.Path) if err != nil { http.Error(w, err.Error(), 500) return } repo_buf := new(bytes.Buffer) err = repo_tpl.Execute(repo_buf, settings.Path) if err != nil { http.Error(w, err.Error(), 500) return } err = PageTemplate.Execute(w, templateInput{ Root: root_buf.String(), Repo: repo_buf.String(), }) if err != nil { http.Error(w, err.Error(), 500) return } }
// Generate handler functions based on an API definition. func generate(api *raml.APIDefinition, genFile string) { f, err := os.Create(genFile) if err != nil { log.Fatal(err) } defer f.Close() // Write the header - import statements and root handler. f.WriteString(handlerHead) // Start the route map (string to handler). f.WriteString(mapStart) // Add the route map entries. e := template.Must(template.New("mapEntry").Parse(mapEntry)) for name, resource := range api.Resources { generateMap("", name, &resource, e, f) } // Close the route map. f.WriteString(mapEnd) // Now add the HTTP handlers. t := template.Must(template.New("handlerText").Parse(handlerText)) for name, resource := range api.Resources { generateResource("", name, &resource, t, f) } format(f) }
// Bundle stuff... // BUG(echu): need to figure out how to handle conflicts in bundle names func (ctx *Context) Bundle(bundlePath string) error { log.Printf("==> Creating bundle from '%s'", bundlePath) defer log.Printf("<== Bundling complete.") log.Printf(" | Parsing bundle config.") bundleConfig, err := ParseBundleFromDir(bundlePath) if err != nil { return err } log.Printf(" %v", bundleConfig) log.Printf(" | Making temp file for python wrapper") wrapper, err := ioutil.TempFile(bundlePath, "plumber") defer removeTempFile(wrapper) if err != nil { return err } log.Printf(" Created '%s'", wrapper.Name()) templateCtx := templateContext{ Wrapper: path.Base(wrapper.Name()), Plumber: bundleConfig, } log.Printf(" | Writing wrapper.") tmpl, err := template.New("wrapper").Parse(wrapperTemplate) if err != nil { return err } if err := tmpl.Execute(wrapper, templateCtx); err != nil { return err } log.Printf(" Done.") log.Printf(" | Making temp file for Dockerfile") dockerfile, err := ioutil.TempFile(bundlePath, "plumber") defer removeTempFile(dockerfile) if err != nil { return err } log.Printf(" Created '%s'", dockerfile.Name()) log.Printf(" | Writing Dockerfile.") tmpl, err = template.New("dockerfile").Parse(dockerfileTemplate) if err != nil { return err } if err := tmpl.Execute(dockerfile, templateCtx); err != nil { return err } log.Printf(" Done.") log.Printf(" | Building container.") err = shell.RunAndLog(ctx.DockerCmd, "build", "--pull", "-t", ctx.GetImage(bundleConfig.Name), "-f", dockerfile.Name(), bundlePath) if err != nil { return err } log.Printf(" Container '%s' built.", ctx.GetImage(bundleConfig.Name)) return nil }
// Initialize all templates func init() { var err error fn := template.FuncMap{ "tabs": Tabs, "add": func(a, b int) int { return a + b }, "goify": Goify, "gotyperef": GoTypeRef, "gotypename": GoTypeName, "transformAttribute": transformAttribute, "transformArray": transformArray, "transformHash": transformHash, "transformObject": transformObject, "typeName": typeName, } if transformT, err = template.New("transform").Funcs(fn).Parse(transformTmpl); err != nil { panic(err) // bug } if transformArrayT, err = template.New("transformArray").Funcs(fn).Parse(transformArrayTmpl); err != nil { panic(err) // bug } if transformHashT, err = template.New("transformHash").Funcs(fn).Parse(transformHashTmpl); err != nil { panic(err) // bug } if transformObjectT, err = template.New("transformObject").Funcs(fn).Parse(transformObjectTmpl); err != nil { panic(err) // bug } }
//Output sub command helps func (gohanClientCLI *GohanClientCLI) outputSubCommands(command string) (string, error) { schemas, err := gohanClientCLI.getSchemas() command = strings.TrimSpace(command) buf := new(bytes.Buffer) if err != nil { return "", err } //Output schema specific help for _, schema := range schemas { if command == schema.ID { tmpl, _ := template.New("schema").Parse(schemaTemplate) tmpl.Execute(buf, schema) return buf.String(), nil } } tmpl, _ := template.New("schema").Parse(schemaListTemplate) if command != "" { buf.WriteString("Command not found") return buf.String(), nil } for _, schema := range schemas { tmpl.Execute(buf, schema) } return buf.String(), nil }
// Generate will call the generator to generate // results func (g *generator) Generate() error { err := g.Prepare() if err != nil { return err } // compile package template packTmpl, err := template.New("package").Parse(packageTemplate) if err != nil { return err } // compile model template tmpl, err := template.New("model").Parse(modelTemplate) if err != nil { return err } for _, resource := range *g.Resources { if model, ok := resource.(*Model); ok { genlog.Info("Generating model for %s", model.Name) content := bytes.Buffer{} packTmpl.Execute(&content, g) tmpl.Execute(&content, model) g.SaveFile(model.Name, content) // set other meta to model model.Package = g.PackageName() } } return nil }
// Init parses all the given singel and layout templates. And stores them in the // template cache. func (t *TemplateEngine) Init() { for layout, templates := range t.templWithLayout { layout, err := ioutil.ReadFile(path.Join(t.root, layout)) handleErr(err) for _, page := range templates { parsedLayout, err := template.New("_").Parse(string(layout)) handleErr(err) templ, err := ioutil.ReadFile(path.Join(t.root, page)) handleErr(err) parsedTempl, err := parsedLayout.Parse(string(templ)) handleErr(err) t.cache[page] = parsedTempl } } for _, file := range t.templates { templ, err := ioutil.ReadFile(path.Join(t.root, file)) handleErr(err) parsedTempl, err := template.New("_").Parse(string(templ)) handleErr(err) t.cache[file] = parsedTempl } }