// RenderInto combines Render() and writing its results into an io.Writer.
// This is a convenience method for frameworks providing a Writer interface,
// such as net/http's ServeHTTP()
func (tx *Xslate) RenderInto(w io.Writer, template string, vars Vars) error {
bc, err := tx.Loader.Load(template)
if err != nil {
return err
}
tx.VM.Run(bc, vm.Vars(vars), w)
return nil
}
// RenderString takes a string argument and treats it as the template
// content. Like `Render()`, this template is parsed and compiled. Because
// there's no way to establish template "freshness", the resulting bytecode
// from `RenderString()` is not cached for reuse.
//
// If you *really* want to change this behavior, it's not impossible to
// bend Xslate's Loader mechanism to cache strings as well, but the main
// Xslate library will probably not adopt this feature.
func (tx *Xslate) RenderString(template string, vars Vars) (string, error) {
_, file, line, _ := runtime.Caller(1)
bc, err := tx.Loader.LoadString(fmt.Sprintf("%s:%d", file, line), template)
if err != nil {
return "", err
}
buf := &bytes.Buffer{}
tx.VM.Run(bc, vm.Vars(vars), buf)
return buf.String(), nil
}
// RenderString takes a string argument and treats it as the template
// content. Like `Render()`, this template is parsed and compiled. Because
// there's no way to establish template "freshness", the resulting bytecode
// from `RenderString()` is not cached for reuse.
//
// If you *really* want to change this behavior, it's not impossible to
// bend Xslate's Loader mechanism to cache strings as well, but the main
// Xslate library will probably not adopt this feature.
func (tx *Xslate) RenderString(template string, vars Vars) (string, error) {
_, file, line, _ := runtime.Caller(1)
bc, err := tx.Loader.LoadString(fmt.Sprintf("%s:%d", file, line), template)
if err != nil {
return "", errors.Wrap(err, "failed to parse template string")
}
buf := rbpool.Get()
defer rbpool.Release(buf)
tx.VM.Run(bc, vm.Vars(vars), buf)
return buf.String(), nil
}
// Configure is called automatically from `New()` to configure the xslate
// instance from arguments
func (tx *Xslate) Configure(args ConfigureArgs) error {
// The compiler currently does not have any configurable options, but
// one may want to replace the entire compiler struct
defaults := map[string]func(*Xslate, Args) error{
"Compiler": DefaultCompiler,
"Parser": DefaultParser,
"Loader": DefaultLoader,
"VM": DefaultVM,
}
for _, key := range []string{"Parser", "Compiler", "Loader", "VM"} {
configKey := "Configure" + key
configuror, ok := args.Get(configKey)
if !ok {
configuror = defaults[key]
}
args, ok := args.Get(key)
if !ok {
args = Args{}
}
err := tx.configureGeneric(configuror, args.(Args))
if err != nil {
return err
}
}
// Configure Functions
if funcs, ok := args.Get("Functions"); ok {
tx.VM.SetFunctions(vm.Vars(funcs.(Args)))
}
if Debug {
tx.DumpAST(true)
tx.DumpByteCode(true)
}
return nil
}