func prepTemplate(parent *template.Template, fn, base string) error {
t := parent.New(base)
f, err := os.Open(fn)
if err != nil {
return err
}
defer f.Close()
msg, err := mail.ReadMessage(f)
if err != nil {
return err
}
for k, v := range defaultHeaders {
if msg.Header.Get(k) == "" {
msg.Header[k] = v
}
}
data := &bytes.Buffer{}
// This is the only place I could find this method. :/
http.Header(msg.Header).Write(data)
data.Write([]byte{'\r', '\n'})
_, err = io.Copy(data, msg.Body)
if err != nil {
return err
}
_, err = t.Parse(data.String())
return err
}
func makeTemplates(t *[]TemplateConfig) (*template.Template, error) {
var textTemplates *template.Template
var err error
templateFuncs := template.FuncMap{"padBefore": PadBefore}
for i, templateConfig := range *t {
t := ""
h := ""
for i, l := range templateConfig.Lines {
if i > 0 {
t = t + "\t"
h = h + "\t"
}
t = t + l.Value
h = h + l.Header
}
// Template proper
if i == 0 {
textTemplates, err = template.New(templateConfig.Name).Funcs(templateFuncs).Parse(t)
} else {
textTemplates, err = textTemplates.New(templateConfig.Name).Funcs(templateFuncs).Parse(t)
}
// Template header
textTemplates, err = textTemplates.New(templateConfig.Name + "_H").Funcs(templateFuncs).Parse(h)
if err != nil {
break
}
}
return textTemplates, err
}
// LoadText loads a template from a possibly inlined VFS as an associated template to the parent
func LoadTextOnto(fs vfs.Opener, parent *txttmpl.Template, tName, fName string) (*txttmpl.Template, error) {
src, err := templateSource(fs, fName)
if err != nil {
return nil, err
}
var tpl *txttmpl.Template
if parent == nil {
tpl = txttmpl.New(tName)
} else {
tpl = parent.New(tName)
}
return tpl.Parse(src)
}
func NewTemplating(partials *txttmpl.Template, filePath, content string) (*Templating, error) {
t := Templating{
name: filePath,
content: CleanupOfTemplate(content),
functions: TemplateFunctions,
}
if partials == nil {
partials = txttmpl.New(t.name)
}
tmpl, err := partials.New(t.name).Funcs(t.functions).Funcs(map[string]interface{}(gtf.GtfFuncMap)).Parse(t.content)
t.template = tmpl
return &t, err
}
func addTemplate(t *template.Template, tname, fname string) (*template.Template, error) {
buf, err := ioutil.ReadFile(fname)
if err != nil {
return nil, err
}
var nt *template.Template
if t != nil {
nt = t.New(tname)
} else {
nt = template.New(tname)
}
return nt.Parse(string(buf))
}
// Parse parses declared templates.
func Parse(t *template.Template) (*template.Template, error) {
for name, s := range templates {
var tmpl *template.Template
if t == nil {
t = template.New(name)
}
if name == t.Name() {
tmpl = t
} else {
tmpl = t.New(name)
}
if _, err := tmpl.Parse(s); err != nil {
return nil, err
}
}
return t, nil
}
func SetTemplate(t *template.Template, name, filename string) error {
// Read template
buf, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
// Update if exists
if tt := t.Lookup(name); tt != nil {
_, err = tt.Parse(string(buf))
return err
}
// Allocate new name if not
_, err = t.New(name).Parse(string(buf))
return err
}
func (t *TemplateDir) LoadPartial() error {
partials := []string{}
directory, err := os.Open(t.src)
if err != nil {
return errs.WithEF(err, t.fields, "Failed to open template dir")
}
objects, err := directory.Readdir(-1)
if err != nil {
return errs.WithEF(err, t.fields, "Failed to read template dir")
}
for _, obj := range objects {
if !obj.IsDir() && strings.HasSuffix(obj.Name(), ".partial") {
partials = append(partials, t.src+"/"+obj.Name())
}
}
if len(partials) == 0 {
return nil
}
var tmpl *txttmpl.Template
for _, partial := range partials {
if tmpl == nil {
tmpl = txttmpl.New(partial).Funcs(TemplateFunctions).Funcs(map[string]interface{}(gtf.GtfFuncMap))
} else {
tmpl = tmpl.New(partial).Funcs(TemplateFunctions).Funcs(map[string]interface{}(gtf.GtfFuncMap))
}
content, err := ioutil.ReadFile(partial)
if err != nil {
return errs.WithEF(err, t.fields.WithField("partial", partial), "Cannot read partial file")
}
tmpl, err = tmpl.Funcs(TemplateFunctions).Parse(CleanupOfTemplate(string(content)))
if err != nil {
return errs.WithEF(err, t.fields.WithField("partial", partial), "Failed to parse partial")
}
}
t.Partials = tmpl
return nil
}
//loadTemplate 加载解析模板
func (d *dynamic) loadTemplate(currDir string) (*template.Template, error) {
if len(d.Template) == 0 {
return nil, fmt.Errorf(ErrorPageNotTemplate)
}
var (
t *template.Template = nil
filePath, fileName, content string
b []byte
err error
)
for _, filename := range d.Template {
filePath = filepath.Join(currDir, filename)
fileName = filepath.Base(filename)
b, err = ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
content = d.formatTemplate(string(b))
var tmpl *template.Template
if t == nil {
t = template.New(fileName)
}
if fileName == t.Name() {
tmpl = t
} else {
tmpl = t.New(fileName)
}
tmpl.Delims(d.Delims.Left, d.Delims.Right)
tmpl.Funcs(TemplateFuncMap)
_, err = tmpl.Parse(content)
if err != nil {
return nil, err
}
}
return t, nil
}
func NewSunnyPublisher(p string) *SunnyPublisher {
var htmpl *htemplate.Template = htemplate.New("index.html")
var tmpl *template.Template = template.New("index")
var plen int = 0
if strings.Contains(p, `\`) {
p = strings.Replace(p, `\`, "/", -1)
} else if p == "" {
p = DEFAULT_VIEWPATH
}
if plen = len(p); p[plen-1] != "/" {
p = p + "/"
plen += 1
}
filepath.Walk(p, func(path string, info os.FileInfo, err error) error {
if err == nil && !info.IsDir() {
b, err := ioutil.ReadFile(path)
if err == nil {
if strings.HasSuffix(info.Name(), ".html") {
htmpl.New(path[plen:]).Parse(string(b))
} else {
tmpl.New(path[plen:]).Parse(string(b))
}
}
}
return nil
})
return &SunnyPublisher{
renderer: make(map[string]Renderer),
htmpl: htmpl,
tmpl: tmpl,
}
}
func addTemplate(base *template.Template, name string, filename string) *template.Template {
text := loadTemplateText(filename)
return template.Must(base.New(name).Parse(text))
}