func (ctx *TemplateContext) Transform(writer io.Writer, descriptor string) error {
var t *template.Template
if b, err := ioutil.ReadFile(descriptor); err != nil {
return err
} else {
var e error
t = template.New(descriptor).Funcs(Funcs)
t, e = t.Parse(string(b))
if e != nil {
return e
}
if matches, err := filepath.Glob("./**/*.tmpl"); err == nil && len(matches) > 0 {
if t, e = t.ParseFiles(matches...); err != nil {
return err
}
}
}
environment := viper.GetString(ENV_NAME)
m := ctx.mergeAppWithDefault(strings.ToLower(environment))
if err := t.Execute(writer, m); err != nil {
return err
}
return nil
}
// Render updates the given destinationPath according to the given template and options.
// Returns true if the file was created or changed, false if nothing has changed.
func Render(templateName, destinationPath string, options interface{}, destinationFileMode os.FileMode) (bool, error) {
asset, err := Asset(templateName)
if err != nil {
return false, maskAny(err)
}
// parse template
var tmpl *template.Template
tmpl = template.New(templateName)
funcMap := template.FuncMap{
"escape": escape,
"quote": strconv.Quote,
}
tmpl.Funcs(funcMap)
_, err = tmpl.Parse(string(asset))
if err != nil {
return false, maskAny(err)
}
// execute template to buffer
buf := &bytes.Buffer{}
tmpl.Funcs(funcMap)
err = tmpl.Execute(buf, options)
if err != nil {
return false, maskAny(err)
}
// Update file
changed, err := util.UpdateFile(destinationPath, buf.Bytes(), destinationFileMode)
return changed, maskAny(err)
}
func applyTemplate(t *template.Template, name string, data interface{}) []byte {
var buf bytes.Buffer
if err := t.Execute(&buf, data); err != nil {
log.Printf("%s.Execute: %s", name, err)
}
return buf.Bytes()
}
/*
* Render page
*
* @param pageFilePath (string)
* @param w (http.ResponseWriter)
*
* @return (error)
*/
func (page *Page) Render(pageFilePath string, w http.ResponseWriter) (err error) {
columnFilePath := page.PageSetting.Layout + ".html"
mainFilePath := "main.html"
contentFilePath := pageFilePath + ".html"
sidebarFilePath := "sidebar.html"
var tmpl *template.Template
switch page.PageSetting.ShowSidebar {
case true:
tmpl, err = template.ParseFiles(
LAYOUT_FOLDER+mainFilePath,
LAYOUT_FOLDER+columnFilePath,
LAYOUT_FOLDER+sidebarFilePath,
STATIC_FOLDER+contentFilePath)
case false:
tmpl, err = template.ParseFiles(
LAYOUT_FOLDER+mainFilePath,
LAYOUT_FOLDER+columnFilePath,
STATIC_FOLDER+contentFilePath)
}
if err != nil {
return
}
tmpl.Execute(w, page)
return
}
// execTmpl executes the provided template on the data, emitting the string.
// It presumes that the input data is semantically correct for the template.
func execTmpl(t *template.Template, data interface{}) string {
var b bytes.Buffer
if err := t.Execute(&b, data); err != nil {
panic("drum: " + err.Error())
}
return b.String()
}
func getServiceURLWithClient(client *unversioned.Client, ip, namespace, service string, t *template.Template) (string, error) {
port, err := getServicePort(client, namespace, service)
if err != nil {
return "", err
}
var doc bytes.Buffer
err = t.Execute(&doc, ipPort{ip, port})
if err != nil {
return "", err
}
u, err := url.Parse(doc.String())
if err != nil {
return "", err
}
annotations, err := getServiceAnnotations(client, namespace, service)
if err != nil {
return "", err
}
if scheme, ok := annotations[serviceAPIAnnotationScheme]; ok {
u.Scheme = scheme
}
if path, ok := annotations[serviceAPIAnnotationPath]; ok && len(u.Path) == 0 {
u.Path = path
}
return u.String(), nil
}
func generateCode(outputFile string, tmpl *template.Template, pkg string, parsed *parser.Thrift) error {
wrappedServices, err := wrapServices(parsed)
if err != nil {
log.Fatalf("Service parsing error: %v", err)
}
buf := &bytes.Buffer{}
td := TemplateData{
Package: pkg,
Services: wrappedServices,
ThriftImport: *apacheThriftImport,
TChannelImport: tchannelThriftImport,
}
if err := tmpl.Execute(buf, td); err != nil {
return fmt.Errorf("failed to execute template: %v", err)
}
generated := cleanGeneratedCode(buf.Bytes())
if err := ioutil.WriteFile(outputFile, generated, 0666); err != nil {
return fmt.Errorf("cannot write output file %s: %v", outputFile, err)
}
// Run gofmt on the file (ignore any errors)
exec.Command("gofmt", "-w", outputFile).Run()
return nil
}
func diffOutput(got string, wantTmpl *template.Template) (string, error) {
got = filepath.ToSlash(got)
wantBuf := new(bytes.Buffer)
data := outputData{
NDK: ndkVersion,
GOOS: goos,
GOARCH: goarch,
GOPATH: gopath,
NDKARCH: ndkarch,
BuildScript: unixBuildScript,
}
if goos == "windows" {
data.EXE = ".exe"
data.BuildScript = windowsBuildScript
}
if err := wantTmpl.Execute(wantBuf, data); err != nil {
return "", err
}
want := wantBuf.String()
if got != want {
return diff(got, want)
}
return "", nil
}
func (blankPanel blankPanel) generate(terminal, packageName string, employee Employee) []byte {
var t *template.Template
var buf bytes.Buffer
t = template.New("blankpanel.html")
t, err := t.ParseFiles("../lessgo/template/component/" + terminal + "/blankpanel.html")
if err != nil {
Log.Error(err.Error())
return []byte{}
}
data := make(map[string]interface{})
data["BlankPanel"] = blankPanel
data["Terminal"] = terminal
data["Employee"] = employee
err = t.Execute(&buf, data)
if err != nil {
Log.Error(err.Error())
return []byte{}
}
return buf.Bytes()
}
/**
* 単語学習ページの表示
* play.html 学習ページ全体のテンプレート
*/
func play(w http.ResponseWriter, r *http.Request) {
type Contents struct {
Words string
}
var c appengine.Context
var u *user.User
var contents *Contents
var err error
var page *template.Template
var entities []Entity
var bytes []byte
c = appengine.NewContext(r)
u = user.Current(c)
// 単語一覧を取得
entities = get(c, u)
// JSONに変換
bytes, err = json.Marshal(entities)
Check(c, err)
contents = new(Contents)
contents.Words = string(bytes)
// ページテンプレート取得
page, err = template.ParseFiles("server/play.html")
Check(c, err)
// 表示
page.Execute(w, contents)
}
// ShowMessage opens a message dialog to show the user a message.
func (w *Workflow) ShowMessage(message string) (err error) {
script :=
`tell application "Alfred {{.Version}}"
activate
set alfredPath to (path to application "Alfred {{.Version}}")
set alfredIcon to path to resource "appicon.icns" in bundle (alfredPath as alias)
display dialog "{{.Prompt}}" with title "{{.Title}}" buttons {"Ok"} default button "Ok" with icon alfredIcon
end tell`
data := struct {
Version string
Prompt string
Title string
}{os.Getenv("alfred_short_version"), message, w.name}
var tmpl *template.Template
tmpl, err = template.New("script").Parse(script)
if err != nil {
return
}
var buf bytes.Buffer
err = tmpl.Execute(&buf, data)
if err != nil {
return
}
script = buf.String()
_, err = RunScript(script)
return
}
func (slConfig *SyslogConfig) logrotateRender(t *template.Template) ([]byte, error) {
var buffer bytes.Buffer
if err := t.Execute(&buffer, slConfig); err != nil {
return nil, err
}
return buffer.Bytes(), nil
}
func (pw PackageWrapper) writePri(filename string, tpl *template.Template, data interface{}) error {
var file *os.File
var err error
// create the vendor directory if needed
if _, err = os.Stat(core.Vendor); err != nil {
err = os.Mkdir(core.Vendor, 0755)
}
// re-create the .pri file
file, err = os.Create(filename)
if err != nil {
return err
}
defer file.Close()
err = tpl.Execute(file, data)
if err != nil {
return err
}
return nil
}
// Generate a dockerfile for the given deployment
func createDockerfile(d *DeployInfo) ([]byte, error) {
// use de-reference to create a copy
info := *d
var buf bytes.Buffer
var tmpl *template.Template
switch d.Lang {
case Python2:
tmpl = pyTmpl
if info.BaseImage == "" {
info.BaseImage = "yhat/scienceops-python:0.0.2"
}
case R:
if d.CRANMirror == "" {
// Create a copy of the DeployInfo to appease the race detector.
info.CRANMirror = YhatCRANMirror
}
if info.BaseImage == "" {
info.BaseImage = "yhat/scienceops-r:0.0.2"
}
tmpl = rTmpl
default:
return nil, fmt.Errorf("unrecognized language passed to dockerfile generation '%s'", d.Lang)
}
if err := tmpl.Execute(&buf, &info); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func genConfig(appPath string, data map[string]string) error {
var src, dest *os.File
var fileContent []byte
var err error
var tmpl *template.Template
name := filepath.Join(appPath, "conf", "app.cnf.template")
if src, err = os.Open(name); err != nil {
return err
}
tmpfile := name
defer func() { src.Close(); os.Remove(tmpfile) }()
name = filepath.Join(appPath, "conf", "app.cnf")
if dest, err = os.OpenFile(name, os.O_CREATE|os.O_WRONLY, 0666); err != nil {
return nil
}
defer dest.Close()
if fileContent, err = ioutil.ReadAll(src); err != nil {
return err
}
if tmpl, err = template.New("").Parse(string(fileContent)); err != nil {
return err
}
return tmpl.Execute(dest, data)
}
func writeTmpl(tmpl *template.Template, vmConfigs []vm) {
file, err := os.Create(tmpl.Name())
checkError(err)
defer file.Close()
err = tmpl.Execute(file, vmConfigs)
checkError(err)
}
func (suite *ExamplesSuite) executeTemplate(tmpl *template.Template) {
cqlshCmd := exec.Command("cqlsh")
inPipe, inPipeErr := cqlshCmd.StdinPipe()
if nil != inPipeErr {
panic(inPipeErr.Error())
}
if startErr := cqlshCmd.Start(); nil != startErr {
panic(startErr.Error())
}
data := struct {
Keyspace string
Id gocql.UUID
}{
Keyspace: cassandraConfig.Keyspace,
Id: suite.id,
}
if renderErr := tmpl.Execute(inPipe, data); nil != renderErr {
panic(renderErr.Error())
}
inPipe.Close()
if waitErr := cqlshCmd.Wait(); nil != waitErr {
panic(waitErr.Error())
}
}
func waitForWatcher(ctx context.Context, watcher *inotify.Watcher, match matcherFunc, tpl *template.Template, monitor bool) {
defer watcher.Close()
for {
select {
case <-ctx.Done(): // Timeout
os.Exit(2)
return
case ev := <-watcher.Event:
if !match(ev) {
break
}
if tpl != nil {
tpl.Execute(os.Stdout, ev)
log.Infoln()
} else {
log.Infoln(ev)
}
// Finish if not monitoring mode.
if !monitor {
return
}
case err := <-watcher.Error:
log.Fatal(err)
}
}
}
func RunTemplate(reportFilename, templateFile, templateText string, out *os.File, data interface{}, format string) (err error) {
var tmpl *template.Template
var htmpl *htemplate.Template
if templateFile != "" {
if format == "html" {
htmpl, err = htemplate.New(templateFile).ParseGlob(templateFile)
} else {
tmpl, err = template.New(templateFile).ParseGlob(templateFile)
}
} else {
if format == "html" {
htmpl, err = htemplate.New(reportFilename).Parse(templateText)
} else {
tmpl, err = template.New(reportFilename).Parse(templateText)
}
}
if err != nil {
return err
}
if format == "html" {
err = htmpl.Execute(out, data)
} else {
err = tmpl.Execute(out, data)
}
if err != nil {
return err
}
return err
}
// respond responds to a request by executing the html template t with data.
func Respond(w http.ResponseWriter, t *template.Template, data interface{}) {
fmt.Println("Respond")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := t.Execute(w, data); err != nil {
log.Print(err)
}
}
func WriteTemplate(temp *template.Template, out string, data interface{}) {
file, err := os.Create(path.Clean(out))
defer file.Close()
HandleError(err)
HandleError(temp.Execute(file, data))
}
func executeTemplate(tmpl *template.Template, data interface{}) (string, error) {
var cmdBuffer bytes.Buffer
if err := tmpl.Execute(&cmdBuffer, data); err != nil {
return "", err
}
return cmdBuffer.String(), nil
}
func generatePage(t *template.Template, data interface{}) ([]byte, error) {
buffer := bytes.NewBuffer(nil)
if err := t.Execute(buffer, data); err != nil {
return nil, err
}
return buffer.Bytes(), nil
}
func (c *Config) writePlaylist(mount, ext string, t *template.Template) error {
for i, s := range c.Server {
if s.Kind == "master" {
continue
}
url := fmt.Sprintf("%s%s", c.ServerURL(s), mount)
servers := []string{url}
for j, s := range c.Server {
if s.Kind == "master" || i == j {
continue
}
url := fmt.Sprintf("%s%s", c.ServerURL(s), mount)
servers = append(servers, url)
}
name := fmt.Sprintf("%s-%s.%s", mount, s.Name, ext)
f, err := os.Create(name)
if err != nil {
return err
}
if err := t.Execute(f, servers); err != nil {
return err
}
f.Close()
}
return nil
}
// execute runs the given go-template over the given context.
func (temp *Templater) Execute(name string, templateStr string, context interface{}) string {
var parsed *template.Template = nil
// Check the cache.
cached, isCached := temp.templateCache.Get(templateStr)
if !isCached {
t := template.New(name)
parsedTemplate, err := t.Parse(templateStr)
if err != nil {
panic(err)
}
temp.templateCache.Set(templateStr, parsedTemplate)
parsed = parsedTemplate
} else {
parsed = cached.(*template.Template)
}
// Execute the template.
var source bytes.Buffer
eerr := parsed.Execute(&source, context)
if eerr != nil {
panic(eerr)
}
return source.String()
}
func exportTileset(filename string, tmpl *template.Template) {
fmt.Printf("Processing %s\n", filename)
file, err := os.Open(filename)
if err != nil {
log.Fatal(err)
}
tileset, err := tmx.Read(file)
if err != nil {
log.Fatal(err)
}
luaFilename := strings.Replace(filepath.Base(filename), filepath.Ext(filename), ".lua", 1)
outputPath := filepath.Join(filepath.Dir(filename), luaFilename)
output, err := os.Create(outputPath)
if err != nil {
log.Fatal(err)
}
err = tmpl.Execute(output, tileset)
if err != nil {
log.Fatal(err)
}
}
func diffOutput(got string, wantTmpl *template.Template) (string, error) {
got = filepath.ToSlash(got)
wantBuf := new(bytes.Buffer)
data := outputData{
NDK: ndkVersion,
GOOS: goos,
GOARCH: goarch,
GOPATH: gopath,
NDKARCH: ndkarch,
Xproj: projPbxproj,
Xcontents: contentsJSON,
Xinfo: infoplistTmplData{Name: "Basic"},
NumCPU: strconv.Itoa(runtime.NumCPU()),
}
if goos == "windows" {
data.EXE = ".exe"
}
if err := wantTmpl.Execute(wantBuf, data); err != nil {
return "", err
}
want := wantBuf.String()
if got != want {
return diff(got, want)
}
return "", nil
}
func Render(templateName string, options interface{}) (string, error) {
asset, err := Asset(templateName)
if err != nil {
return "", maskAny(err)
}
// parse template
var tmpl *template.Template
tmpl = template.New(templateName)
funcMap := template.FuncMap{
"escape": escape,
"quote": strconv.Quote,
"yamlPrefix": yamlPrefix,
}
tmpl.Funcs(funcMap)
_, err = tmpl.Parse(string(asset))
if err != nil {
return "", maskAny(err)
}
// write file to buffer
tmpl.Funcs(funcMap)
buffer := &bytes.Buffer{}
err = tmpl.Execute(buffer, options)
if err != nil {
return "", maskAny(err)
}
return buffer.String(), nil
}
// write writes the configuration file, will write to stdout if dryRun == true
func (cfg *loadBalancerConfig) write(services map[string][]service, dryRun bool) (err error) {
var w io.Writer
if dryRun {
w = os.Stdout
} else {
w, err = os.Create(cfg.Config)
if err != nil {
return
}
}
var t *template.Template
t, err = template.ParseFiles(cfg.Template)
if err != nil {
return
}
conf := make(map[string]interface{})
conf["startSyslog"] = strconv.FormatBool(cfg.startSyslog)
conf["services"] = services
// default load balancer algorithm is roundrobin
conf["defLbAlgorithm"] = lbDefAlgorithm
if cfg.lbDefAlgorithm != "" {
conf["defLbAlgorithm"] = cfg.lbDefAlgorithm
}
err = t.Execute(w, conf)
return
}
// formatErrorDescription takes a string in the default text/template
// format and converts it to a string with replacements. The fields come
// from the ErrorDetails struct and vary for each type of error.
func formatErrorDescription(s string, details ErrorDetails) string {
var tpl *template.Template
var descrAsBuffer bytes.Buffer
var err error
if errorTemplates == nil {
errorTemplates = template.New("all-errors")
}
tpl = errorTemplates.Lookup(s)
if tpl == nil {
tpl = errorTemplates.New(s)
tpl, err = tpl.Parse(s)
if err != nil {
return err.Error()
}
}
err = tpl.Execute(&descrAsBuffer, details)
if err != nil {
return err.Error()
}
return descrAsBuffer.String()
}