Esempio n. 1
1
func NewTemplate() *template.Template {
	return template.New("").Funcs(template.FuncMap(map[string]interface{}{
		"q": func(fieldName string) (interface{}, error) {
			return nil, errors.New("The q template dummy function was called")
		},
	}))
}
Esempio n. 2
0
func TestTemplateFuncMap_join(t *testing.T) {
	app := kocha.NewTestApp()
	funcMap := template.FuncMap(app.Template.FuncMap)
	tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{join .Arr .Sep}}`))
	var buf bytes.Buffer
	for _, v := range []struct {
		Arr    interface{}
		Sep    string
		expect string
	}{
		{[]int{1, 2, 3}, "&", "1&2&3"},
		{[2]uint{12, 34}, " and ", "12 and 34"},
		{[]string{"alice", "bob", "carol"}, ", ", "alice, bob, carol"},
		{[]string(nil), "|", ""},
		{[]bool{}, " or ", ""},
		{[]interface{}{"1", 2, "three", uint32(4)}, "-", "1-2-three-4"},
		{[]string{"あ", "い", "う", "え", "お"}, "_", "あ_い_う_え_お"},
		{[]string{"a", "b", "c"}, "∧", "a∧b∧c"},
	} {
		buf.Reset()
		if err := tmpl.Execute(&buf, v); err != nil {
			t.Error(err)
			continue
		}
		actual := buf.String()
		expect := v.expect
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`{{join %#v %#v}} => %#v; want %#v`, v.Arr, v.Sep, actual, expect)
		}
	}
}
Esempio n. 3
0
func TestTemplate_FuncMap_url(t *testing.T) {
	app := kocha.NewTestApp()
	funcMap := template.FuncMap(app.Template.FuncMap)

	func() {
		tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{url "root"}}`))
		var buf bytes.Buffer
		if err := tmpl.Execute(&buf, nil); err != nil {
			panic(err)
		}
		actual := buf.String()
		expected := "/"
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf("Expect %q, but %q", expected, actual)
		}
	}()

	func() {
		tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{url "user" 713}}`))
		var buf bytes.Buffer
		if err := tmpl.Execute(&buf, nil); err != nil {
			panic(err)
		}
		actual := buf.String()
		expected := "/user/713"
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf("Expect %v, but %v", expected, actual)
		}
	}()
}
Esempio n. 4
0
// TemplatesFuncs adds functions that will be available to all templates.
// It is legal to overwrite elements of the map.
func TemplatesFuncs(funcs FuncMap) {
	if templates == nil {
		panic(errNoTemplatesDir)
	}

	templates.Funcs(template.FuncMap(funcs))
}
Esempio n. 5
0
func TestTemplateFuncMap_flash(t *testing.T) {
	c := newTestContext("testctrlr", "")
	funcMap := template.FuncMap(c.App.Template.FuncMap)
	for _, v := range []struct {
		key    string
		expect string
	}{
		{"", ""},
		{"success", "test succeeded"},
		{"success", "test successful"},
		{"error", "test failed"},
		{"error", "test failure"},
	} {
		c.Flash = kocha.Flash{}
		c.Flash.Set(v.key, v.expect)
		tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(fmt.Sprintf(`{{flash . "unknown"}}{{flash . "%s"}}`, v.key)))
		var buf bytes.Buffer
		if err := tmpl.Execute(&buf, c); err != nil {
			t.Error(err)
			continue
		}
		actual := buf.String()
		expect := v.expect
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`{{flash . %#v}} => %#v; want %#v`, v.key, actual, expect)
		}
	}
}
Esempio n. 6
0
func BenchmarkBigGo(b *testing.B) {
	b.ReportAllocs()
	tmpl := template.New("")
	tmpl.Funcs(template.FuncMap{"t": func(s string) string { return s }})
	tmpl.Funcs(template.FuncMap(templateFuncs.asTemplateFuncMap()))
	readFile := func(name string) string {
		data, err := ioutil.ReadFile(filepath.Join("_testdata", name))
		if err != nil {
			b.Fatal(err)
		}
		return "{{ $Vars := .Vars }}\n" + string(data)
	}
	if _, err := tmpl.Parse(readFile("1.html")); err != nil {
		b.Fatal(err)
	}
	t2 := tmpl.New("2.html")
	if _, err := t2.Parse(readFile("2.html")); err != nil {
		b.Fatal(err)
	}
	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, nil); err != nil {
		b.Fatal(err)
	}
	buf.Reset()
	b.ResetTimer()
	for ii := 0; ii < b.N; ii++ {
		tmpl.Execute(&buf, nil)
		buf.Reset()
	}
}
Esempio n. 7
0
func TestTemplate_FuncMap_in(t *testing.T) {
	app := kocha.NewTestApp()
	funcMap := template.FuncMap(app.Template.FuncMap)
	var buf bytes.Buffer
	for _, v := range []struct {
		Arr    interface{}
		Sep    interface{}
		expect string
		err    error
	}{
		{[]string{"b", "a", "c"}, "a", "true", nil},
		{[]string{"ab", "b", "c"}, "a", "false", nil},
		{nil, "a", "", fmt.Errorf("valid types are slice, array and string, got `invalid'")},
	} {
		buf.Reset()
		tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{in .Arr .Sep}}`))
		err := tmpl.Execute(&buf, v)
		if !strings.HasSuffix(fmt.Sprint(err), fmt.Sprint(v.err)) {
			t.Errorf(`{{in %#v %#v}}; error has "%v"; want "%v"`, v.Arr, v.Sep, err, v.err)
		}
		actual := buf.String()
		expect := v.expect
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`{{in %#v %#v}} => %#v; want %#v`, v.Arr, v.Sep, actual, expect)
		}
	}
}
Esempio n. 8
0
// Creates HTML template with predefined functions
func NewHtml(name string) *template.Template {
	tmpl := template.New(name)

	extends := template.FuncMap(map[string]interface{}{
		"extends": func(name string, data interface{}) (html template.HTML, err error) {
			buf := bytes.NewBuffer([]byte{})

			if err = tmpl.ExecuteTemplate(buf, name, data); err == nil {
				html = template.HTML(buf.String())
			}

			return
		},
	})

	return tmpl.Funcs(template.FuncMap(coreFuncs)).Funcs(extends)
}
Esempio n. 9
0
func NewConf(name string, backends conf.EnabledBackends, text string) (c *Conf, err error) {
	defer errRecover(&err)
	c = &Conf{
		Name:             name,
		Vars:             make(map[string]string),
		Templates:        make(map[string]*conf.Template),
		Alerts:           make(map[string]*conf.Alert),
		Notifications:    make(map[string]*conf.Notification),
		RawText:          text,
		bodies:           htemplate.New(name).Funcs(htemplate.FuncMap(defaultFuncs)),
		subjects:         ttemplate.New(name).Funcs(defaultFuncs),
		Lookups:          make(map[string]*conf.Lookup),
		Macros:           make(map[string]*conf.Macro),
		writeLock:        make(chan bool, 1),
		deferredSections: make(map[string][]deferredSection),
		backends:         backends,
	}
	c.tree, err = parse.Parse(name, text)
	if err != nil {
		c.error(err)
	}
	saw := make(map[string]bool)
	for _, n := range c.tree.Root.Nodes {
		c.at(n)
		switch n := n.(type) {
		case *parse.PairNode:
			c.seen(n.Key.Text, saw)
			c.loadGlobal(n)
		case *parse.SectionNode:
			c.loadSection(n)
		default:
			c.errorf("unexpected parse node %s", n)
		}
	}

	loadSections := func(sectionType string) {
		for _, dSec := range c.deferredSections[sectionType] {
			c.at(dSec.SectionNode)
			dSec.LoadFunc(dSec.SectionNode)
		}
	}

	loadSections("template")
	if c.unknownTemplate != "" {
		t, ok := c.Templates[c.unknownTemplate]
		if !ok {
			c.errorf("template not found: %s", c.unknownTemplate)
		}
		c.UnknownTemplate = t
	}
	loadSections("notification")
	loadSections("macro")
	loadSections("lookup")
	loadSections("alert")

	c.genHash()
	return
}
Esempio n. 10
0
func (c *Conf) loadTemplate(s *parse.SectionNode) {
	name := s.Name.Text
	if _, ok := c.Templates[name]; ok {
		c.errorf("duplicate template name: %s", name)
	}
	t := conf.Template{
		Vars: make(map[string]string),
		Name: name,
	}
	t.Text = s.RawText
	t.Locator = newSectionLocator(s)
	funcs := ttemplate.FuncMap{
		"V": func(v string) string {
			return c.Expand(v, t.Vars, false)
		},
	}
	saw := make(map[string]bool)
	for _, p := range s.Nodes.Nodes {
		c.at(p)
		switch p := p.(type) {
		case *parse.PairNode:
			c.seen(p.Key.Text, saw)
			v := p.Val.Text
			switch k := p.Key.Text; k {
			case "body":
				t.RawBody = v
				tmpl := c.bodies.New(name).Funcs(htemplate.FuncMap(funcs))
				_, err := tmpl.Parse(t.RawBody)
				if err != nil {
					c.error(err)
				}
				t.Body = tmpl
			case "subject":
				t.RawSubject = v
				tmpl := c.subjects.New(name).Funcs(funcs)
				_, err := tmpl.Parse(t.RawSubject)
				if err != nil {
					c.error(err)
				}
				t.Subject = tmpl
			default:
				if !strings.HasPrefix(k, "$") {
					c.errorf("unknown key %s", k)
				}
				t.Vars[k] = v
				t.Vars[k[1:]] = t.Vars[k]
			}
		default:
			c.errorf("unexpected node")
		}
	}
	c.at(s)
	if t.Body == nil && t.Subject == nil {
		c.errorf("neither body or subject specified")
	}
	c.Templates[name] = &t
}
Esempio n. 11
0
func TestTemplate_FuncMap_in_withInvalidType(t *testing.T) {
	app := kocha.NewTestApp()
	funcMap := template.FuncMap(app.Template.FuncMap)
	tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{in 1 1}}`))
	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, nil); err == nil {
		t.Errorf("Expect errors, but no errors")
	}
}
Esempio n. 12
0
func MakeMixer(tpdir string, fMap map[string]interface{}) func(...string) *template.Template {
	return func(fileNames ...string) *template.Template {
		names := make([]string, len(fileNames))
		for i, val := range fileNames {
			names[i] = tpdir + val + ".html"
		}
		return template.Must(template.New("").Funcs(template.FuncMap(fMap)).ParseFiles(names...))
	}
}
Esempio n. 13
0
func New(name, text string) (c *Conf, err error) {
	defer errRecover(&err)
	c = &Conf{
		Name:             name,
		CheckFrequency:   time.Minute * 5,
		DefaultRunEvery:  1,
		HTTPListen:       ":8070",
		StateFile:        "bosun.state",
		LedisDir:         "ledis_data",
		LedisBindAddr:    "127.0.0.1:9565",
		MinGroupSize:     5,
		PingDuration:     time.Hour * 24,
		ResponseLimit:    1 << 20, // 1MB
		SearchSince:      opentsdb.Day * 3,
		TSDBVersion:      &opentsdb.Version2_1,
		UnknownThreshold: 5,
		Vars:             make(map[string]string),
		Templates:        make(map[string]*Template),
		Alerts:           make(map[string]*Alert),
		Notifications:    make(map[string]*Notification),
		RawText:          text,
		bodies:           htemplate.New(name).Funcs(htemplate.FuncMap(defaultFuncs)),
		subjects:         ttemplate.New(name).Funcs(defaultFuncs),
		Lookups:          make(map[string]*Lookup),
		Macros:           make(map[string]*Macro),
	}
	c.tree, err = parse.Parse(name, text)
	if err != nil {
		c.error(err)
	}
	saw := make(map[string]bool)
	for _, n := range c.tree.Root.Nodes {
		c.at(n)
		switch n := n.(type) {
		case *parse.PairNode:
			c.seen(n.Key.Text, saw)
			c.loadGlobal(n)
		case *parse.SectionNode:
			c.loadSection(n)
		default:
			c.errorf("unexpected parse node %s", n)
		}
	}
	if c.Hostname == "" {
		c.Hostname = c.HTTPListen
		if strings.HasPrefix(c.Hostname, ":") {
			h, err := os.Hostname()
			if err != nil {
				c.at(nil)
				c.error(err)
			}
			c.Hostname = h + c.Hostname
		}
	}
	return
}
Esempio n. 14
0
// Loads localization, template functions and executes the template.
func (d *Display) execute(wr io.Writer, fileContents string) error {
	loc, err := display_model.LoadLocTempl(d.ctx.FileSys(), fileContents, d.ctx.User().Languages()) // TODO: think about errors here.
	if err != nil {
		return err
	}
	vctx := d.ctx.ViewContext()
	vctx.Publish("loc", loc)
	funcMap := template.FuncMap(builtins(d.ctx))
	t, err := template.New("tpl").Funcs(funcMap).Parse(fileContents)
	if err != nil {
		return err
	}
	return t.Execute(wr, vctx.Get()) // TODO: watch for errors in execution.
}
Esempio n. 15
0
func TestTemplate_FuncMap_nl2br(t *testing.T) {
	app := kocha.NewTestApp()
	funcMap := template.FuncMap(app.Template.FuncMap)
	tmpl := template.Must(template.New("test").Funcs(funcMap).Parse(`{{nl2br "a\nb\nc\n"}}`))
	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, nil); err != nil {
		panic(err)
	}
	actual := buf.String()
	expected := "a<br>b<br>c<br>"
	if !reflect.DeepEqual(actual, expected) {
		t.Errorf("Expect %q, but %q", expected, actual)
	}
}
Esempio n. 16
0
/**
* 包含模板 directive
 */
func MyTemplateDirective(tname string, data interface{}) template.HTML {
	s, err := LoadHtmlTemplateToStr(tname)
	if err != nil {
		log.Println("解析模板[", tname, "]错误,", err.Error())
		return template.HTML("")
	}
	t, err := template.New(tname).Funcs(template.FuncMap(PullFuncMap)).Parse(s)
	if err != nil {
		log.Println("解析模板[", tname, "]错误,", err.Error())
		return template.HTML("")
	}
	buff := bytes.NewBufferString("")
	t.Execute(buff, data)
	return template.HTML(buff.String())
}
Esempio n. 17
0
/**
* 编译html为go模板
 */
func ParseTemplate(tname string) (*template.Template, error) {
	tmpl_str, err := LoadHtmlTemplateToStr(tname)
	if err != nil {
		log.Println("加载模板失败,", err.Error())
		return nil, err
	}
	//second compile html string
	//parse模版
	t, err := template.New(tname).Funcs(template.FuncMap(PullFuncMap)).Parse(tmpl_str)
	if err != nil {
		log.Println("编译模板失败!", err.Error())
		return nil, err
	}
	return t, nil
}
Esempio n. 18
0
func main() {

	settings := evergreen.GetSettingsOrExit()
	home := evergreen.FindEvergreenHome()
	uis, err := ui.New(settings, home)
	if err != nil {
		fmt.Println("Failed to create ui server: %v", err)
		os.Exit(1)
	}
	router, err := uis.NewRouter()
	if err != nil {
		fmt.Println("Failed to create router:", err)
		os.Exit(1)
	}

	webHome := filepath.Join(uis.Home, "public")

	functionOptions := ui.FuncOptions{webHome, uis.Settings.Ui.HelpUrl, true, router}

	functions, err := ui.MakeTemplateFuncs(functionOptions, uis.Settings.SuperUsers)
	htmlFunctions := htmlTemplate.FuncMap(functions)
	textFunctions := textTemplate.FuncMap(functions)

	if err != nil {
		fmt.Println("Failed to create template function map:", err)
		os.Exit(1)
	}

	uis.Render = render.New(render.Options{
		Directory:    filepath.Join(uis.Home, ui.WebRootPath, ui.Templates),
		DisableCache: !uis.Settings.Ui.CacheTemplates,
		HtmlFuncs:    htmlFunctions,
		TextFuncs:    textFunctions,
	})
	err = uis.InitPlugins()
	if err != nil {
		fmt.Println("WARNING: Error initializing plugins:", err)
	}

	n := negroni.New()
	n.Use(negroni.NewStatic(http.Dir(webHome)))
	n.Use(ui.NewLogger())
	n.Use(negroni.HandlerFunc(ui.UserMiddleware(uis.UserManager)))
	n.UseHandler(router)
	graceful.Run(uis.Settings.Ui.HttpListenAddr, requestTimeout, n)
	evergreen.Logger.Logf(slogger.INFO, "UI server cleanly terminated")
}
Esempio n. 19
0
func (this *SunnyPublisher) Publish(wr io.Writer, name string, data interface{}) {
	// TODO: use sync.Pool instead once GAE supports 1.3

	// get cloned template from pool
	// add contextual funcmap to the template

	if strings.HasSuffix(name, ".html") {
		ht, err := this.htmpl.Clone()
		ht.Funcs(htemplate.FuncMap(this.fmap))

		if err == nil {
			ht = ht.Lookup(name)
			if ht != nil {
				ht.Execute(wr, data)
			} else {
				goto renderer
			}
		} else {
			goto renderer
		}
	} else {
		ht, err := this.tmpl.Clone()
		ht.Funcs(template.FuncMap(this.fmap))

		if err == nil {
			if ht != nil {
				ht.Execute(wr, data)
			} else {
				goto renderer
			}
		} else {
			goto renderer
		}
	}

	return

renderer:
	ext := ".html"
	b, err := this.renderer[ext](name, data)
	if err == nil {
		wr.Write(b)
	}
}
Esempio n. 20
0
func (t *Template) buildAppTemplateSet(buf *bytes.Buffer, l int, m map[templateKey]*template.Template, appName string, templates map[string]map[string]string) error {
	for ext, templateInfos := range templates {
		tmpl := template.New("")
		for name, path := range templateInfos {
			buf.Truncate(l)
			var body string
			if data := t.app.ResourceSet.Get(path); data != nil {
				if b, ok := data.(string); ok {
					buf.WriteString(b)
					body = buf.String()
				}
			} else {
				f, err := os.Open(path)
				if err != nil {
					return err
				}
				_, err = io.Copy(buf, f)
				f.Close()
				if err != nil {
					return err
				}
				body = buf.String()
				t.app.ResourceSet.Add(path, body)
			}
			if _, err := tmpl.New(name).Delims(t.LeftDelim, t.RightDelim).Funcs(template.FuncMap(t.FuncMap)).Parse(body); err != nil {
				return err
			}
		}
		for _, t := range tmpl.Templates() {
			key := templateKey{
				appName: appName,
				name:    strings.TrimSuffix(t.Name(), ext),
				format:  ext[1:], // truncate the leading dot.
			}
			if strings.HasPrefix(key.name, layoutPath) {
				key.isLayout = true
				key.name = key.name[len(layoutPath):]
			}
			m[key] = t
		}
	}
	return nil
}
Esempio n. 21
0
// Parse is converts the input data into html.
func (h *HTML) Parse(f []Field) string {
	t := defaultTemplate

	if h.Template != "" {
		// template check
		_, err := os.Stat(h.Template)
		if err == nil {
			t = template.Must(template.New(filepath.Base(h.Template)).Funcs(template.FuncMap(fns)).ParseFiles(h.Template))
		} else {
			log.Warnf("template does not exist: %s, stat error: %v", h.Template, err)
		}
	}

	var buffer bytes.Buffer
	err := t.Execute(&buffer, map[string]interface{}{"fields": f})
	if err != nil {
		log.Panicf("execute template error: %v", err)
	}

	return buffer.String()
}
Esempio n. 22
0
// Loads localization, template functions and executes the template.
func prepareAndExec(uni *context.Uni, file string) {
	root := uni.Root
	host := uni.Req.Host
	dat := uni.Dat
	opt := uni.Opt
	w := uni.W
	langs, has := jsonp.Get(dat, "_user.languages") // _user should always has languages field
	if !has {
		langs = []string{"en"}
	}
	langs_s := toStringSlice(langs)
	if !has {
		langs = []string{"en"}
	}
	loc, _ := display_model.LoadLocTempl(file, langs_s, root, scut.GetTPath(opt, host), nil) // TODO: think about errors here.
	dat["loc"] = merge(dat["loc"], loc)
	funcMap := template.FuncMap(builtins(uni))
	t, _ := template.New("tpl").Funcs(funcMap).Parse(string(file))
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	t.Execute(w, dat) // TODO: watch for errors in execution.
}
Esempio n. 23
0
// FromGlobs calls ParseGlob on all path globs provided and returns the
// resulting Template.
func FromGlobs(paths ...string) (*Template, error) {
	t := &Template{
		text: tmpltext.New("").Option("missingkey=zero"),
		html: tmplhtml.New("").Option("missingkey=zero"),
	}
	var err error

	t.text = t.text.Funcs(tmpltext.FuncMap(DefaultFuncs))
	t.html = t.html.Funcs(tmplhtml.FuncMap(DefaultFuncs))

	b, err := deftmpl.Asset("template/default.tmpl")
	if err != nil {
		return nil, err
	}
	if t.text, err = t.text.Parse(string(b)); err != nil {
		return nil, err
	}
	if t.html, err = t.html.Parse(string(b)); err != nil {
		return nil, err
	}

	for _, tp := range paths {
		// ParseGlob in the template packages errors if not at least one file is
		// matched. We want to allow empty matches that may be populated later on.
		p, err := filepath.Glob(tp)
		if err != nil {
			return nil, err
		}
		if len(p) > 0 {
			if t.text, err = t.text.ParseGlob(tp); err != nil {
				return nil, err
			}
			if t.html, err = t.html.ParseGlob(tp); err != nil {
				return nil, err
			}
		}
	}
	return t, nil
}
Esempio n. 24
0
//newHtemplate adds funcmap to template var and parse files.
func newHtemplate(templateDir string) *Htemplate {
	t := &Htemplate{htmlTemplate.New("")}
	t.Funcs(htmlTemplate.FuncMap(funcMap))
	templateFiles := filepath.Join(templateDir, "*.txt")

	if util.IsDir(templateDir) {
		_, err := t.ParseGlob(templateFiles)
		if err != nil {
			log.Fatal(err)
		}
	}
	mat, err := filepath.Glob(templateFiles)
	if err != nil {
		log.Fatal(err)
	}
	e := make(map[string]struct{})
	for _, m := range mat {
		e[filepath.Base(m)] = struct{}{}
	}
	dir, err := util.AssetDir("gou_template")
	if err != nil {
		log.Fatal(err)
	}
	for _, a := range dir {
		if _, exist := e[path.Base(a)]; exist {
			continue
		}
		c, err := util.Asset(path.Join("gou_template", a))
		if err != nil {
			log.Fatal(err)
		}

		if _, err := t.Parse(string(c)); err != nil {
			log.Fatal(err)
		}
	}

	return t
}
Esempio n. 25
0
func (r *HTMLTemplateRenderer) Render(name string, vars librenderer.M) ([]byte, error) {
	if r.memcache == nil {
		r.memcache = make(map[string]*template.Template)
	}

	if r.memlock == nil {
		r.memlock = new(sync.Mutex)
	}

	r.memlock.Lock()
	defer r.memlock.Unlock()

	tpl, exists := r.memcache[name]
	if !exists {
		src, err := r.Assets.Asset(name)
		if err != nil {
			return []byte{}, err
		}

		tpl, err = template.New(name).Parse(string(src))
		if err != nil {
			return []byte{}, err
		}

		if r.Funcs != nil {
			tpl = tpl.Funcs(template.FuncMap(r.Funcs))
		}

		r.memcache[name] = tpl
	}

	b := new(bytes.Buffer)
	if err := tpl.Execute(b, vars); err != nil {
		return []byte{}, err
	}

	return b.Bytes(), nil
}
Esempio n. 26
0
func benchmarkHTMLTemplate(b *testing.B, tests []*templateTest) {
	b.ReportAllocs()
	templates := make([]*template.Template, len(tests))
	for ii, v := range tests {
		tmpl := template.New("template.html")
		tmpl.Funcs(template.FuncMap(templateFuncs.asTemplateFuncMap()))
		_, err := tmpl.Parse(v.tmpl)
		if err != nil {
			b.Fatalf("can't parse %q: %s", v.tmpl, err)
		}
		// Execute once to add the escaping hooks
		tmpl.Execute(ioutil.Discard, nil)
		templates[ii] = tmpl
	}
	var buf bytes.Buffer
	b.ResetTimer()
	for ii := 0; ii < b.N; ii++ {
		for ii, v := range templates {
			v.Execute(&buf, tests[ii].data)
		}
		buf.Reset()
	}
}
Esempio n. 27
0
// ExpandHTML expands a template with HTML escaping, with templates read from the given files.
func (te Expander) ExpandHTML(templateFiles []string) (result string, resultErr error) {
	defer func() {
		if r := recover(); r != nil {
			var ok bool
			resultErr, ok = r.(error)
			if !ok {
				resultErr = fmt.Errorf("panic expanding template %v: %v", te.name, r)
			}
		}
	}()

	tmpl := html_template.New(te.name).Funcs(html_template.FuncMap(te.funcMap))
	tmpl.Option("missingkey=zero")
	tmpl.Funcs(html_template.FuncMap{
		"tmpl": func(name string, data interface{}) (html_template.HTML, error) {
			var buffer bytes.Buffer
			err := tmpl.ExecuteTemplate(&buffer, name, data)
			return html_template.HTML(buffer.String()), err
		},
	})
	tmpl, err := tmpl.Parse(te.text)
	if err != nil {
		return "", fmt.Errorf("error parsing template %v: %v", te.name, err)
	}
	if len(templateFiles) > 0 {
		_, err = tmpl.ParseFiles(templateFiles...)
		if err != nil {
			return "", fmt.Errorf("error parsing template files for %v: %v", te.name, err)
		}
	}
	var buffer bytes.Buffer
	err = tmpl.Execute(&buffer, te.data)
	if err != nil {
		return "", fmt.Errorf("error executing template %v: %v", te.name, err)
	}
	return buffer.String(), nil
}
Esempio n. 28
0
func (t *Templates) ParseDir(dir, prefix string, funcMap FuncMap) {
	filepath.Walk(dir, func(p string, i os.FileInfo, e error) error {
		if i == nil || i.IsDir() {
			return nil
		}
		if strings.HasSuffix(p, ".tmpl.html") || !strings.HasSuffix(p, ".html") {
			return nil
		}
		rel, err := filepath.Rel(dir, p)
		if err != nil {
			return err
		}

		r, err := t.processTemplate(dir, rel)
		if err != nil {
			panic(err)
		}
		b := &bytes.Buffer{}
		if _, err = b.ReadFrom(r); err != nil {
			panic(err)
		}

		n := prefix + filepath.ToSlash(rel)
		t.m[n] = template.New(``).Funcs(template.FuncMap(funcMap))
		template.Must(t.m[n].Parse(b.String()))

		if _, err = os.Stat(path.Join(dir, rel[:len(rel)-5], "index.html")); os.IsNotExist(err) {
			t.m[n[:len(n)-5]] = t.m[n]
		}

		if len(rel) >= 10 && rel[len(rel)-10:] == "index.html" {
			t.m[strings.TrimRight(n[:len(n)-10], "/")] = t.m[n]
		}
		return nil
	})
}
Esempio n. 29
0
func main() {
	settings := evergreen.GetSettingsOrExit()
	if settings.Ui.LogFile != "" {
		evergreen.SetLogger(settings.Ui.LogFile)
	}
	db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(settings))

	home := evergreen.FindEvergreenHome()

	userManager, err := auth.LoadUserManager(settings.AuthConfig)
	if err != nil {
		fmt.Println("Failed to create user manager:", err)
		os.Exit(1)
	}

	cookieStore := sessions.NewCookieStore([]byte(settings.Ui.Secret))

	uis := ui.UIServer{
		nil,             // render
		settings.Ui.Url, // RootURL
		userManager,     // User Manager
		*settings,       // mci settings
		cookieStore,     // cookiestore
		nil,             // plugin panel manager
	}
	router, err := uis.NewRouter()
	if err != nil {
		fmt.Println("Failed to create router:", err)
		os.Exit(1)
	}

	webHome := filepath.Join(home, "public")

	functionOptions := ui.FuncOptions{webHome, settings.Ui.HelpUrl, true, router}

	functions, err := ui.MakeTemplateFuncs(functionOptions, settings.SuperUsers)
	htmlFunctions := htmlTemplate.FuncMap(functions)
	textFunctions := textTemplate.FuncMap(functions)

	if err != nil {
		fmt.Println("Failed to create template function map:", err)
		os.Exit(1)
	}

	uis.Render = render.New(render.Options{
		Directory:    filepath.Join(home, ui.WebRootPath, ui.Templates),
		DisableCache: !settings.Ui.CacheTemplates,
		HtmlFuncs:    htmlFunctions,
		TextFuncs:    textFunctions,
	})
	err = uis.InitPlugins()
	if err != nil {
		fmt.Println("WARNING: Error initializing plugins:", err)
	}

	n := negroni.New()
	n.Use(negroni.NewStatic(http.Dir(webHome)))
	n.Use(ui.NewLogger())
	n.Use(negroni.HandlerFunc(ui.UserMiddleware(userManager)))
	n.UseHandler(router)
	graceful.Run(settings.Ui.HttpListenAddr, requestTimeout, n)
	evergreen.Logger.Logf(slogger.INFO, "UI server cleanly terminated")
}
Esempio n. 30
0
File: html.go Progetto: rsc/go-misc
var htmlFuncs = template.FuncMap(map[string]interface{}{
	"pct": pct,
	"lastRev": func(classes []*failureClass) *Revision {
		// TODO: Ugh. It's lame that the same Revs is in every
		// failureClass.
		revs := classes[0].Revs
		return revs[len(revs)-1]
	},
	"numCommits": func(r FlakeRegion) int {
		return r.Last - r.First + 1
	},
	"groupByT": func(failures []*failure) map[int][]*failure {
		out := make(map[int][]*failure)
		if len(failures) == 0 {
			return out
		}
		lastI, lastT := 0, failures[0].T
		for i := 1; i < len(failures); i++ {
			if failures[i].T != lastT {
				out[lastT] = failures[lastI:i]
				lastI, lastT = i, failures[i].T
			}
		}
		out[lastT] = failures[lastI:]
		return out
	},
	"slice": func(v interface{}, start, end int) interface{} {
		val := reflect.ValueOf(v)
		if start < 0 {
			start = val.Len() + start
		}
		if end < 0 {
			end = val.Len() + end
		}
		return val.Slice(start, end).Interface()
	},
})