-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathapitpl.go
More file actions
268 lines (240 loc) · 6.51 KB
/
apitpl.go
File metadata and controls
268 lines (240 loc) · 6.51 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
// Package apitpl implements template engine
// which renders templates by executing them 2 times, one for content and another one for layout.
package apitpl
import (
"bytes"
"fmt"
"github.com/pkg/errors"
"html/template"
"io"
"github.com/oxtoacart/bpool"
"github.com/apisite/apitpl/lookupfs"
)
// codebeat:disable[TOO_MANY_IVARS]
// TemplateService holds templates data & methods
type TemplateService struct {
lfs *lookupfs.LookupFileSystem
funcMap template.FuncMap
layouts map[string]*template.Template
pages map[string]*template.Template
baseTemplate *template.Template
bufPool *bpool.BufferPool
useCustomContent bool
parseAlways bool
}
// codebeat:enable[TOO_MANY_IVARS]
// New creates TemplateService with BufferPool of given size
func New(size int) (tfs *TemplateService) {
tfs = &TemplateService{
funcMap: template.FuncMap{
"content": func() string { return "" },
},
bufPool: bpool.NewBufferPool(size),
}
return tfs
}
// LookupFS sets lookup filesystem
func (tfs *TemplateService) LookupFS(fs *lookupfs.LookupFileSystem) *TemplateService {
tfs.lfs = fs
return tfs
}
// ParseAlways disables template caching
func (tfs *TemplateService) ParseAlways(flag bool) *TemplateService {
tfs.parseAlways = flag
return tfs
}
// Funcs loads initial funcmap
func (tfs *TemplateService) Funcs(funcMap template.FuncMap) *TemplateService {
for k, v := range funcMap {
tfs.funcMap[k] = v
if k == "content" {
tfs.useCustomContent = true
}
}
return tfs
}
// PageNames returns page names for router setup
func (tfs TemplateService) PageNames(hide bool) []string {
return tfs.lfs.PageNames(hide)
}
// Parse parses all of service templates
func (tfs *TemplateService) Parse() (*TemplateService, error) {
err := tfs.lfs.LookupAll()
if err != nil {
return nil, err
}
includes, err := tfs.parseIncludes(tfs.lfs.Includes)
if err != nil {
return nil, err
}
layouts, err := tfs.parseTemplates(includes, tfs.lfs.Layouts)
if err != nil {
return nil, err
}
pages, err := tfs.parseTemplates(includes, tfs.lfs.Pages)
if err != nil {
return nil, err
}
tfs.baseTemplate = includes
tfs.layouts = *layouts
tfs.pages = *pages
return tfs, nil
}
// parseIncludes parses included templates
func (tfs TemplateService) parseIncludes(items map[string]lookupfs.File) (*template.Template, error) {
var t *template.Template
for k, f := range items {
s, err := tfs.lfs.ReadFile(f.Path)
if err != nil {
return nil, err
}
var tmpl *template.Template
if t == nil {
t = template.New(k)
tmpl = t
} else {
tmpl = t.New(k)
}
_, err = tmpl.Funcs(tfs.funcMap).Parse(s)
if err != nil {
return nil, err
}
}
return t, nil
}
// parseTemplates parses all page & layout templates
func (tfs TemplateService) parseTemplates(includes *template.Template, items map[string]lookupfs.File) (*map[string]*template.Template, error) {
templates := map[string]*template.Template{}
for k, f := range items {
tmpl, err := tfs.parseTemplate(includes, k, f)
if err != nil {
return nil, errors.Wrap(err, "parse template")
}
templates[k] = tmpl
}
return &templates, nil
}
// parseTemplate parses single template
func (tfs TemplateService) parseTemplate(includes *template.Template, k string, f lookupfs.File) (*template.Template, error) {
s, err := tfs.lfs.ReadFile(f.Path)
if err != nil {
return nil, err
}
t := includes
var tmpl *template.Template
if t == nil {
tmpl = template.New(k)
} else {
tmpl, err = t.Clone()
if err != nil {
return nil, err
}
tmpl = tmpl.New(k)
}
_, err = tmpl.Funcs(tfs.funcMap).Parse(s)
return tmpl, err
}
func (tfs TemplateService) parseTemplateWithDeps(items map[string]lookupfs.File, name string) (*template.Template, error) {
includes, err := tfs.parseIncludes(tfs.lfs.Includes)
if err != nil {
return nil, err
}
f, ok := items[name]
if !ok {
err := fmt.Errorf("page %s does not exists", name)
return nil, err
}
return tfs.parseTemplate(includes, name, f)
}
// MetaData holds template metadata access methods
type MetaData interface {
Error() error // Template exec error
SetError(error) // Store unhandler template error
Layout() string // Return layout name
}
// Execute renders page content and layout
func (tfs TemplateService) Execute(wr io.Writer, name string, funcs template.FuncMap, data MetaData) error {
return tfs.Render(wr, funcs, data, tfs.RenderContent(name, funcs, data))
}
// RenderContent renders page content
func (tfs TemplateService) RenderContent(name string, funcs template.FuncMap, data MetaData) *bytes.Buffer {
var tmpl *template.Template
var err error
if tfs.parseAlways {
tmpl, err = tfs.parseTemplateWithDeps(tfs.lfs.Pages, name)
if err != nil {
data.SetError(err)
return nil
}
} else {
var ok bool
tmpl, ok = tfs.pages[name] // TODO: tfs.Lookup(tfs.pages, name)
if !ok {
err = fmt.Errorf("page %s does not exists", name)
data.SetError(err)
return nil
}
}
buf := tfs.bufPool.Get()
err = tmpl.Funcs(funcs).ExecuteTemplate(buf, name, data)
if err != nil {
tfs.bufPool.Put(buf)
data.SetError(err)
return nil
}
return buf
}
// layout returns metadata layout (if exists) or default layout otherwise
func (tfs TemplateService) layout(name string, data MetaData) *template.Template {
tmpl, ok := tfs.layouts[name]
if !ok {
err := fmt.Errorf("layout %s does not exist", name)
data.SetError(err)
tmpl = tfs.layouts[tfs.lfs.DefaultLayout()]
}
return tmpl
}
// Render renders layout with prepared content
func (tfs TemplateService) Render(w io.Writer, funcs template.FuncMap, data MetaData, content *bytes.Buffer) (err error) {
name := data.Layout()
if name == "" {
// No layout needed
if content != nil {
_, err := content.WriteTo(w)
tfs.bufPool.Put(content)
if err != nil {
data.SetError(err)
}
}
return nil
}
var tmpl *template.Template
if tfs.parseAlways {
var err error
tmpl, err = tfs.parseTemplateWithDeps(tfs.lfs.Layouts, name)
if err != nil {
data.SetError(err)
// TODO: parse default layout?
tmpl = tfs.layouts[tfs.lfs.DefaultLayout()]
}
} else {
tmpl = tfs.layout(name, data)
}
buf := tfs.bufPool.Get()
defer tfs.bufPool.Put(buf)
if !tfs.useCustomContent && content != nil {
funcs["content"] = func() string { return content.String() }
}
err = tmpl.Funcs(funcs).ExecuteTemplate(buf, name, data)
if content != nil {
tfs.bufPool.Put(content)
}
if err != nil {
return errors.Wrap(err, "exec layout")
}
_, err = buf.WriteTo(w)
if err != nil {
return errors.Wrap(err, "exec layout write")
}
return nil
}