Golang Template.Clone方法代码示例

// ApplyTemplate is internal. Gets a the template, clones and executes.
// getter is called after l.Init so it can rely on l.Template presence.
func (l *LazyTemplate) ApplyTemplate(getter func() (*template.Template, string), data interface{}) (*bytes.Buffer, error) {
	var clone *template.Template
	if err := func() error {
		l.MU.Lock()
		defer l.MU.Unlock()
		if err := l.Init(); err != nil {
			return err
		}
		var t *template.Template
		if getter == nil {
			t = l.Template
		} else {
			var name string
			t, name = getter()
			if t == nil {
				return fmt.Errorf("template: %q is undefined", name)
			}
		}
		var err error
		clone, err = t.Clone()
		return err
	}(); err != nil {
		return nil, err
	}
	buf := new(bytes.Buffer)
	err := clone.Execute(buf, data)
	return buf, err
}

func (tl *TemplateLoader) loadTemplates(searchPath string, includeTmpl *template.Template) error {
	tmplFiles, err := filepath.Glob(filepath.Join(tl.basePath, searchPath, "*.tmpl"))
	if err != nil {
		return err
	}

	for _, tf := range tmplFiles {
		tfBytes, err := ioutil.ReadFile(tf)
		if err != nil {
			return err
		}
		tfStr := string(tfBytes)

		tn, err := filepath.Rel(tl.basePath, tf)
		if err != nil {
			return err
		}
		tn = strings.TrimSuffix(tn, ".tmpl")

		// We clone the included templates here to keep each namespace fresh.
		it, err := includeTmpl.Clone()
		if err != nil {
			return err
		}

		t, err := it.New(tn).Parse(tfStr)
		if err != nil {
			return err
		}

		tl.templates[tn] = t
	}

	return nil
}

func getLayoutTemplates() *template.Template {
	var templLayouts *template.Template = template.Must(
		template.ParseGlob("templates/layouts/*.html"))

	temp, _ := templLayouts.Clone()

	return temp
}

func readtemplates(dir string, titles map[Language]string) (err error) {
	var templates *template.Template
	templates, err = template.New("base").Funcs(tmplFuncs).ParseGlob(dir + "/*.tmpl")
	if err != nil {
		return
	}
	var d *os.File
	d, err = os.Open(dir)
	if err != nil {
		return
	}
	var v []os.FileInfo
	v, err = d.Readdir(0)
	if err != nil {
		return
	}
	for _, fi := range v {
		if fi.IsDir() {
			var t *template.Template
			t, err = templates.Clone()
			if err != nil {
				return
			}
			subdir := dir + "/" + fi.Name()
			_, err = t.ParseGlob(subdir + "/*.tmpl")
			if err != nil {
				return
			}
			th := t.Lookup("home")
			ti := t.Lookup("info")
			if th == nil {
				return fmt.Errorf(`Template "home" is missing in %s`, subdir)
			}
			if ti == nil {
				return fmt.Errorf(`Template "info" is missing in %s`, subdir)
			}
			title, ok := "", false
			if title, ok = titles[Language(fi.Name())]; !ok {
				if title, ok = titles[defaultlang]; !ok {
					title = "Uploader"
				}
			}
			langtmpl[Language(fi.Name())] = &tmpl{title, th, ti}
		}
	}
	defaulttmpl = langtmpl[defaultlang]
	if defaulttmpl == nil {
		fmt.Errorf("missing " + string(defaultlang) + " template")
	}
	languages = make([]Language, 0, len(langtmpl))
	languages = append(languages, defaultlang)
	for k := range langtmpl {
		if k != defaultlang {
			languages = append(languages, k)
		}
	}
	return
}

// LoadTemplates parses all specified files located in fpath. Each template is wrapped
// in a unique clone of layout.  All templates are expecting {{authboss}} handlebars
// for parsing. It will check the override directory specified in the config, replacing any
// templates as necessary.
func LoadTemplates(ab *authboss.Authboss, layout *template.Template, fpath string, files ...string) (Templates, error) {
	m := make(Templates)

	funcMap := template.FuncMap{
		"title": strings.Title,
		"mountpathed": func(location string) string {
			if ab.MountPath == "/" {
				return location
			}
			return path.Join(ab.MountPath, location)
		},
	}

	for _, file := range files {
		b, err := ioutil.ReadFile(filepath.Join(fpath, file))
		if exists := !os.IsNotExist(err); err != nil && exists {
			return nil, err
		} else if !exists {
			b, err = Asset(file)
			if err != nil {
				return nil, err
			}
		}

		clone, err := layout.Clone()
		if err != nil {
			return nil, err
		}

		_, err = clone.New("authboss").Funcs(funcMap).Parse(string(b))
		if err != nil {
			return nil, err
		}

		m[file] = clone
	}

	return m, nil
}

func (h *HtmlRender) getTemplate(root *template.Template, args ...string) (*template.Template, error) {
	var name, file string
	if len(args) == 1 {
		name = args[0]
		file = args[0]
	} else {
		name = args[1]
		file = args[1]
	}
	if !h.saveTemp { //for debug
		log.Println("get template of ", name, file)
	}
	file = filepath.FromSlash(file)
	t := h.models[name]

	if t == nil {
		cloned_rest_model, err := root.Clone()

		if err == nil {

			err = parseFileWithName(cloned_rest_model, name, filepath.Join(h.dir, file))
			if err == nil {
				t = cloned_rest_model.Lookup(name)
				if h.saveTemp {
					h.models[name] = t
				}
			} else {
				if os.IsNotExist(err) {
					log.Printf("template for (%s) is missing", file)
					return nil, ge.NOSUCHROUTER
				} else {
					return nil, err
				}
			}
		}
	}
	return t, nil
}

func templatesCompileDemo(w http.ResponseWriter, r *http.Request, m map[string]interface{}) {

	w.Header().Set("Content-Type", "text/html")

	funcMap := tt.FuncMap{
		"unescape": html.UnescapeString,
		"escape":   html.EscapeString,
	}

	var t_base *tt.Template
	var err error = nil

	// creating T0 - naming it - adding func map
	t_base = tt.Must(tt.New("str_T0_outmost").Funcs(funcMap).Parse(T0))
	loghttp.E(w, r, err, false)

	// adding the definition of T1 - introducing reference to T2 - undefined yet
	t_base, err = t_base.Parse(T1) // definitions must appear at top level - but not at the start
	loghttp.E(w, r, err, false)

	// create two clones
	// now both containing T0 and T1
	tc_1, err := t_base.Clone()
	loghttp.E(w, r, err, false)
	tc_2, err := t_base.Clone()
	loghttp.E(w, r, err, false)

	// adding different T2 definitions
	s_if := "{{if .}}{{.}}{{else}}no dyn data{{end}}"
	tc_1, err = tc_1.Parse("{{define `T2`}}T2-A  <br>--" + s_if + "--  {{end}}")
	loghttp.E(w, r, err, false)
	tc_2, err = tc_2.Parse("{{define `T2`}}T2-B  <br>--" + s_if + "--  {{end}}")
	loghttp.E(w, r, err, false)

	// writing both clones to the response writer
	err = tc_1.ExecuteTemplate(w, "str_T0_outmost", nil)
	loghttp.E(w, r, err, false)

	// second clone is written with dynamic data on two levels
	dyndata := map[string]string{"key1": "dyn val 1", "key2": "dyn val 2"}
	err = tc_2.ExecuteTemplate(w, "str_T0_outmost", dyndata)
	loghttp.E(w, r, err, false)

	// Note: it is important to pass the DOT
	//		 {{template "T1" .}}
	//		 {{template "T2" .key2 }}
	//						 ^
	// otherwise "dyndata" can not be accessed by the inner templates...

	// leaving T2 undefined => error
	tc_3, err := t_base.Clone()
	loghttp.E(w, r, err, false)
	err = tc_3.ExecuteTemplate(w, "str_T0_outmost", dyndata)
	// NOT logging the error:
	// loghttp.E(w, r, err, false)

}

// Renderer is a Middleware that maps a render.Render service into the Martini handler chain. An single variadic render.Options
// struct can be optionally provided to configure HTML rendering. The default directory for templates is "templates" and the default
// file extension is ".tmpl".
//
// If MARTINI_ENV is set to "" or "development" then templates will be recompiled on every request. For more performance, set the
// MARTINI_ENV environment variable to "production"
func Renderer(options ...Options) martini.Handler {
	opt := prepareOptions(options)
	cs := prepareCharset(opt.Charset)
	var t *template.Template
	if opt.Template == nil {
		t = compile(opt)
	}
	return func(res http.ResponseWriter, req *http.Request, c martini.Context) {
		var tc *template.Template
		if opt.Template == nil {
			if martini.Env == martini.Dev {
				// recompile for easy development
				tc = compile(opt)
			} else {
				// use a clone of the initial template
				tc, _ = t.Clone()
			}
		} else {
			tc = opt.Template
		}

		c.MapTo(&renderer{res, req, tc, opt, cs}, (*Render)(nil))
	}
}

// evalTemplate evaluates a single template (path) and saves it to output.
func evalTemplate(path string, output string, t *template.Template, context interface{}) error {
	newT, err := t.Clone()
	if err != nil {
		return err
	}
	tData, err := ioutil.ReadFile(path)
	if err != nil {
		return err
	}

	// Pull out front matter
	tData, context, err = processFrontmatter(tData, context)
	if err != nil {
		return err
	}

	_, err = newT.Parse(string(tData))
	if err != nil {
		return err
	}

	err = os.MkdirAll(filepath.Dir(output), os.ModePerm)
	if err != nil {
		return err
	}

	of, err := os.Create(output)
	if err != nil {
		return err
	}
	defer of.Close()

	// Ideally we wouldn't have to name the template here, but
	// https://github.com/golang/go/issues/12996
	return newT.ExecuteTemplate(of, "<root>", context)
}

// Use Act in order to create an http.Handler that fills a template with the data from an executed Action
// or executes the ErrorHandler in case of an error.
func (l *Layout) Act(respond Action, eh ErrorHandler, volatility Volatility, templates ...string) http.Handler {
	var loadTemplates func() (*template.Template, error)
	var ttl time.Duration
	if eh == nil {
		eh = func(w http.ResponseWriter, r *http.Request, e error) {}
	}
	switch volatility {
	case NoVolatility:
		// Load templates so that we can clone instead of loading every time
		var storedTemplates *template.Template
		lock := sync.Mutex{}
		loadTemplates = func() (*template.Template, error) {
			var err error
			lock.Lock()
			defer lock.Unlock()
			if storedTemplates == nil {
				storedTemplates, err = l.load(templates...)
				if err != nil {
					return nil, err
				}
			}
			return storedTemplates.Clone()
		}
		respond = respond.cache(-1) // cache permanently
		ttl = 7 * 24 * time.Hour
	case LowVolatility:
		ttl = 24 * time.Hour
		fallthrough
	case MediumVolatility:
		if ttl == 0 {
			ttl = 1 * time.Hour
		}
		fallthrough
	case HighVolatility:
		if ttl == 0 {
			ttl = 5 * time.Minute
		}
		var storedTemplates *template.Template
		lock := sync.Mutex{}
		loadTemplates = func() (*template.Template, error) {
			var err error
			// lock to ensure we don't have multiple requests attempting to reload the
			// templates at the same time
			lock.Lock()
			defer lock.Unlock()
			if storedTemplates == nil {
				storedTemplates, err = l.load(templates...)
				if err != nil {
					return nil, err
				}
				time.AfterFunc(ttl, func() {
					lock.Lock()
					defer lock.Unlock()
					storedTemplates = nil
				})
			}
			return storedTemplates.Clone()
		}
		respond = respond.cache(ttl)
	case ExtremeVolatility:
		fallthrough // make this the default value
	default:
		loadTemplates = func() (*template.Template, error) {
			return l.load(templates...)
		}
	}
	// ensure that template loading will work
	template.Must(loadTemplates())
	return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		t, err := loadTemplates()
		if err != nil {
			eh(res, req, err)
			return
		}
		var data map[string]interface{}
		data, err = respond(req)
		if err != nil {
			eh(res, req, err)
			return
		}

		b := new(bytes.Buffer)
		if err = t.ExecuteTemplate(b, l.baseTemplate, data); err != nil {
			eh(res, req, err)
			return
		}
		// Add Client-Side caching
		if volatility < ExtremeVolatility {
			res.Header().Set("Cache-Control", "public, max-age="+strconv.FormatFloat(ttl.Seconds(), 'f', 0, 64))
			res.Header().Set("Expires", time.Now().Add(ttl).Format(time.RFC1123))
		}
		if _, err = b.WriteTo(res); err != nil {
			eh(res, req, err)
		}
	})
}