func (o jsonOutputter) Output(code int, g *gas.Gas) {
h := g.Header()
if _, foundType := h["Content-Type"]; !foundType {
h.Set("Content-Type", "application/json; charset=utf-8")
}
g.WriteHeader(code)
json.NewEncoder(g).Encode(o.data)
}
func (o *templateOutputter) Output(code int, g *gas.Gas) {
templateLock.RLock()
defer templateLock.RUnlock()
group := Templates[o.path]
var t *template.Template
if group == nil {
log.Printf("templates: failed to access template group \"%s\"", o.path)
g.WriteHeader(500)
fmt.Fprintf(g, "Error: template group \"%s\" not found. Did it fail to compile?", o.path)
return
}
partial := g.Request.Header.Get("X-Ajax-Partial") != ""
// If it's a partial page request, try to serve a partial template
// (denoted by a '%' prepended to the template name). If it doesn't
// exist, fall back to the regular one.
if partial && !strings.HasPrefix(o.name, "%") {
t = group.Lookup("%" + o.name)
}
if t == nil {
t = group.Lookup(o.name)
}
if t == nil {
log.Printf("No such template: %s/%s", o.path, o.name)
g.WriteHeader(500)
fmt.Fprintf(g, "Error: no such template: %s/%s", o.path, o.name)
return
}
h := g.Header()
if _, foundType := h["Content-Type"]; !foundType {
h.Set("Content-Type", "text/html; charset=utf-8")
}
var w io.Writer
if strings.Contains(g.Request.Header.Get("Accept-Encoding"), "gzip") {
h.Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(g)
defer gz.Close()
w = io.Writer(gz)
} else {
w = g
}
if !partial && o.layouts != nil && len(o.layouts) > 0 {
layouts := make([]*template.Template, len(o.layouts))
// conceptually the layouts are arranged like this
// [l1, l2, l3] t
// ^
// execution starts at the beginning of the queue. l1 has a link via
// the closure below to l(1+1) = l2, l2 has a link to l3, and l3 has a
// link to t. Once the execution chain starts, each one will fire off
// the next one until it reaches the end, at which point the main
// content template is rendered. The layouts will then be rendered
// outside-in with the main content last (innermost).
// we need this func slice to properly close over the loop variables.
// Otherwise the value of n would be the final value always. The layout
// execution would then always skip all layouts after the first.
funcs := make([]func(), len(o.layouts))
for n, path := range o.layouts {
if err := (func(i int) error {
group, ok := Templates[path.path]
if !ok {
return fmt.Errorf("no such template path %s for layout %s", path.path, path.name)
}
layout := group.Lookup(path.name)
if layout == nil {
return fmt.Errorf("no such layout %s in path %s", path.name, path.path)
}
layouts[i] = layout
// closure closes over:
// - layouts slice so that it can access the next layout,
// - w so that it can write a template with minimal buffering,
// - i so that it knows its position,
// - t to render the final content.
funcs[i] = func() {
f := func() (string, error) {
// If this is the last layout in the queue, then do the
// data instead. Then it'll stop "recursing" to this
// closure.
if i < len(funcs)-1 {
funcs[i+1]()
return "", layouts[i+1].Execute(w, o.data)
}
return "", t.Execute(w, o.data)
}
layout.Funcs(template.FuncMap{"content": f})
}
return nil
})(n); err != nil {
log.Printf("Render: Layouts: %v", err)
g.WriteHeader(500)
fmt.Fprint(w, err)
}
}
g.WriteHeader(code)
funcs[0]()
if err := layouts[0].Execute(w, o.data); err != nil {
fmt.Fprint(w, err)
}
return
}
g.WriteHeader(code)
if err := t.Execute(w, o.data); err != nil {
t = Templates[o.path].Lookup(o.name + "-error")
if t == nil {
fmt.Fprintf(g, "Error: failed to serve error page for %s/%s (error template not found)", o.path, o.name)
return
}
if err = t.Execute(g, err); err != nil {
fmt.Fprintf(g, "Error: failed to serve error page for %s/%s (%v)", o.path, o.name, err)
return
}
}
}
