Ejemplo n.º 1
2
func main() {
	c, err := config.ReadDefault("wiki.ini")
	panicIni(err)
	wikiName, err = c.String("wiki", "name")
	panicIni(err)
	servAddr, err := c.String("wiki", "serv_addr")
	panicIni(err)
	inDevMode, err = c.Bool("wiki", "dev_mode")
	panicIni(err)
	log.Printf("Read wiki.ini")

	views = template.Must(template.ParseGlob("views/[a-z]*.html"))
	log.Printf("Parsed page templates\n")

	http.HandleFunc("/", rootHandler)
	http.HandleFunc("/delete/", deleteHandler)
	http.HandleFunc("/restore/", restoreHandler)
	http.HandleFunc("/edit/", editHandler)
	http.HandleFunc("/preview", previewHandler)
	http.HandleFunc("/save/", saveHandler)
	http.HandleFunc("/pages", pagesHandler)
	http.HandleFunc("/deleted", deletedHandler)
	http.HandleFunc("/versions/", versionsHandler)
	http.HandleFunc("/search", searchHandler)
	http.Handle("/pub/", http.StripPrefix("/pub/", http.FileServer(http.Dir("pub"))))
	http.HandleFunc("/favicon.ico", faviconHandler)
	log.Printf("Serving wiki pages from %s...\n", servAddr)
	log.Fatal(http.ListenAndServe(servAddr, nil))
}
Ejemplo n.º 2
0
func startup() {
	loadConfig()

	log.Printf("Lanyon listening on http://localhost:%d", config.PortNum)

	// add trailing slashes to config directories
	if !strings.HasSuffix(config.PublicDir, "/") {
		config.PublicDir = config.PublicDir + "/"
	}

	// verify public directory exists
	if _, err := os.Stat(config.PublicDir); err != nil {
		log.Fatalln("Public directory does not exist")
	}

	// add trailing slashes to config directories
	if !strings.HasSuffix(config.TemplateDir, "/") {
		config.TemplateDir = config.TemplateDir + "/"
	}

	// verify template directory exists
	if _, err := os.Stat(config.TemplateDir); err != nil {
		log.Fatalln("Template directory does not exist")
	}
	var err error
	ts, err = template.ParseGlob(config.TemplateDir + "*.html")
	if err != nil {
		log.Fatalln("Error Parsing Templates: ", err)
	}

}
Ejemplo n.º 3
0
func main() {
	tpl, err := template.ParseGlob("templates/*.gmao")
	if err != nil {
		log.Fatalln(err)
	}

	err = tpl.Execute(os.Stdout, nil)
	if err != nil {
		log.Fatalln(err)
	}

	err = tpl.ExecuteTemplate(os.Stdout, "vespa.gmao", nil)
	if err != nil {
		log.Fatalln(err)
	}

	err = tpl.ExecuteTemplate(os.Stdout, "two.gmao", nil)
	if err != nil {
		log.Fatalln(err)
	}

	err = tpl.ExecuteTemplate(os.Stdout, "one.gmao", nil)
	if err != nil {
		log.Fatalln(err)
	}
}
Ejemplo n.º 4
0
func FindAndExecuteTemplate(currentDir string, templateName string, concept Concept) error {

	templateDir, err := utils.FindTemplateDir()
	if err != nil {
		return err
	}

	endpointDir, err := MakeEndpointDir(currentDir, concept)
	if err != nil {
		return err
	}
	//TODO assume that js is the only implementation language for now
	templatesGlob := fmt.Sprintf("%v/js/endpoint/*.js", templateDir)

	t, err := template.ParseGlob(templatesGlob)
	if err != nil {
		return err
	}
	outputFileName := fmt.Sprintf("%v/%v", endpointDir, templateName)
	outputFile, err := os.Create(outputFileName)
	if err != nil {
		return err
	}
	return t.ExecuteTemplate(outputFile, templateName, concept)
}
Ejemplo n.º 5
0
func NewTheme(tpath string) *Theme {
	var err error
	var pattern string
	var pages []string
	var base *template.Template
	var tmap = map[string]*template.Template{}

	pattern = path.Join(tpath, "*.html")
	base = template.Must(template.ParseGlob(pattern))
	pattern = path.Join(tpath, "pages", "*.html")
	if pages, err = filepath.Glob(pattern); err != nil {
		panic(err)
	}

	for _, tpath := range pages {
		var ts *template.Template

		if ts, err = base.Clone(); err != nil {
			panic(err)
		}
		if _, err = ts.ParseFiles(tpath); err != nil {
			panic(err)
		}
		tmap[path.Base(tpath)] = ts
	}

	return &Theme{
		Path:      tpath,
		Templates: tmap,
	}
}
Ejemplo n.º 6
0
func Start(conn *CGRConnector, user, pass string) {
	connector = conn
	username = user
	password = pass
	templates = template.Must(template.ParseGlob("templates/*.tmpl"))

	rpc.Register(conn)

	goji.Get(LOGIN_PATH, loginGet)
	goji.Post(LOGIN_PATH, loginPost)

	goji.Get("/app/*", http.FileServer(http.Dir("./static")))

	auth := web.New()
	goji.Handle("/*", auth)
	auth.Use(SessionAuth)
	auth.Handle("/ws", websocket.Handler(func(ws *websocket.Conn) {
		jsonrpc.ServeConn(ws)
	}))
	auth.Post("/import/", importPost)
	auth.Post("/exportcdrs/", exportCdrsPost)
	auth.Post("/exporttpcsv/", exportTpToCsvPost)
	auth.Get("/accounts/logout", logoutGet)
	auth.Get("/", http.RedirectHandler("/app/", 301))
}
Ejemplo n.º 7
0
func ServeServerRoutes(port string, pusher *UDPush.Pusher) {
	Pusher = pusher
	var err error
	T, err = template.ParseGlob("server/templates/*")
	_ = err
	r := mux.NewRouter()
	r.StrictSlash(true)

	// public
	r.HandleFunc("/", IndexHandler)
	r.HandleFunc("/login/", LoginHandler).Methods("GET")
	r.HandleFunc("/sign-up/", SignUpHandler).Methods("POST")
	r.HandleFunc("/file-data/{email}", FilesHandler).Methods("POST")
	r.HandleFunc("/download/{id}/{filename}", DownloadHandler).Methods("GET")

	// require client authentication
	r.HandleFunc("/file-actions/", sessionValidate(FileActionsHandler)).Methods("POST")
	r.HandleFunc("/upload/", sessionValidate(UploadHandler)).Methods("POST")
	r.HandleFunc("/download/", sessionValidate(FileDownloadHandler)).Methods("POST")
	r.HandleFunc("/clients/", sessionValidate(ClientsFileActionsHandler)).Methods("POST")

	// static files? (css, js, etc...)
	// r.PathPrefix("/").Handler(http.FileServer(http.Dir("./public/")))

	http.Handle("/", r)

	fmt.Println("Serving api on port :" + port)
	http.ListenAndServe(":"+port, nil)
}
Ejemplo n.º 8
0
func New(addr string, auth smtp.Auth, templateDir string) (Mailer, error) {
	templates, err := template.ParseGlob(filepath.Join(templateDir, "*.tmpl"))
	if err != nil {
		return nil, err
	}
	return &defaultMailer{addr, auth, templates}, nil
}
Ejemplo n.º 9
0
func init() {
	// /Users/henrilepic/gocode/src/github.com/konginteractive/cme/
	templatesHtml = htmlTempl.Must(htmlTempl.ParseGlob("./app/vues/*"))
	templatesText = textTempl.Must(textTempl.ParseGlob("./app/vues/*"))
	// permet d'avoir quelques variables
	//fmt.Println("YS : " + YS + " / MS : " + MS)
}
func main() {
	res, _ := filepath.Glob("templates\\temp\\*.html")
	log.Printf("%+v", res)
	var templates = template.Must(template.ParseGlob("templates\\temp\\*.html"))
	err := templates.ExecuteTemplate(
		os.Stdout,
		"indexPage",
		View{Content: "foo"},
	)
	if err != nil {
		log.Printf("err: %v", err)
		return
	}

	m := martini.Classic()
	// render html templates from templates directory
	m.Use(render.Renderer(render.Options{
		Directory:  "templates/temp",
		Extensions: []string{".html"},
	}))

	m.Get("/", func(r render.Render) {
		r.HTML(200, "head", View{Content: "tututrutu"}, render.HTMLOptions{Layout: "indexPage"})
	})

	m.Run()
}
Ejemplo n.º 11
0
// ディレクトリにあるテンプレート郡をロードするデモです。
func main() {
	dir := createTestDir([]templateFile{
		// T0.tmpl はT1をコールします。
		{"T0.tmpl", `T0 invokes T1: ({{template "T1"}})`},
		// T1.tmpl T2をコールするテンプレートを"T1"として定義しています。
		{"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
		// T2.tmpl は"T2"としてテンプレートを定義しています。
		{"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
	})
	// main関数終了後、作成したディレクトリを削除します。
	defer os.RemoveAll(dir)

	// dirにあるすべてのテンプレートファイルを検索するようにパターンを作成しています。
	pattern := filepath.Join(dir, "*.tmpl")

	// ここから本題です。
	// T0.tmpl は初めにマッチする名前ですので、始めのテンプレート(ParseGlobの戻り値の値)になります。
	tmpl := template.Must(template.ParseGlob(pattern))
	log.Println(tmpl.Name())

	err := tmpl.Execute(os.Stdout, nil)
	if err != nil {
		log.Fatalf("template execution: %s", err)
	}
	// Output:
	// T0 invokes T1: (T1 invokes T2: (This is T2))
}
Ejemplo n.º 12
0
// Wraps other http handlers. Creates context object, recovers from panics, etc.
func WrapHandlerImpl(fn AppHandlerFunc, parseForm bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		c := &Context{}

		// See http://blog.golang.org/2010/08/defer-panic-and-recover.html.
		defer func() {
			if data := recover(); data != nil {
				c.Aec().Errorf(fmt.Sprint(data))
				ServeError(w, data)
			}
		}()

		// Initialize the request context object.
		c.SetAec(appengine.NewContext(r))
		CheckError(ReadSession(r, c))
		if msg, err := ConsumeFlash(w, r); err != nil && err != http.ErrNoCookie {
			ServeError(w, err)
			return
		} else {
			c.SetFlash(msg)
		}

		if parseForm {
			CheckError(r.ParseForm())
		}

		if appengine.IsDevAppServer() {
			tmpl = template.Must(template.ParseGlob("templates/*.html"))
			text_tmpl = text_template.Must(text_template.ParseGlob("templates/*.txt"))
		}
		fn(w, r, c)
	}
}
Ejemplo n.º 13
0
func TestSendNags(t *testing.T) {
	stats, _ := statsd.NewNoopClient(nil)
	mc := mocks.Mailer{}
	rs := newFakeRegStore()
	fc := newFakeClock(t)

	m := mailer{
		stats:         stats,
		mailer:        &mc,
		emailTemplate: tmpl,
		subject:       testEmailSubject,
		rs:            rs,
		clk:           fc,
	}

	cert := &x509.Certificate{
		Subject: pkix.Name{
			CommonName: "happy",
		},
		NotAfter: fc.Now().AddDate(0, 0, 2),
		DNSNames: []string{"example.com"},
	}

	err := m.sendNags([]*core.AcmeURL{emailA}, []*x509.Certificate{cert})
	test.AssertNotError(t, err, "Failed to send warning messages")
	test.AssertEquals(t, len(mc.Messages), 1)
	test.AssertEquals(t, mocks.MailerMessage{
		To:      emailARaw,
		Subject: testEmailSubject,
		Body:    fmt.Sprintf(`hi, cert for DNS names example.com is going to expire in 2 days (%s)`, cert.NotAfter.Format(time.RFC822Z)),
	}, mc.Messages[0])

	mc.Clear()
	err = m.sendNags([]*core.AcmeURL{emailA, emailB}, []*x509.Certificate{cert})
	test.AssertNotError(t, err, "Failed to send warning messages")
	test.AssertEquals(t, len(mc.Messages), 2)
	test.AssertEquals(t, mocks.MailerMessage{
		To:      emailARaw,
		Subject: testEmailSubject,
		Body:    fmt.Sprintf(`hi, cert for DNS names example.com is going to expire in 2 days (%s)`, cert.NotAfter.Format(time.RFC822Z)),
	}, mc.Messages[0])
	test.AssertEquals(t, mocks.MailerMessage{
		To:      emailBRaw,
		Subject: testEmailSubject,
		Body:    fmt.Sprintf(`hi, cert for DNS names example.com is going to expire in 2 days (%s)`, cert.NotAfter.Format(time.RFC822Z)),
	}, mc.Messages[1])

	mc.Clear()
	err = m.sendNags([]*core.AcmeURL{}, []*x509.Certificate{cert})
	test.AssertNotError(t, err, "Not an error to pass no email contacts")
	test.AssertEquals(t, len(mc.Messages), 0)

	templates, err := template.ParseGlob("../../data/*.template")
	test.AssertNotError(t, err, "Failed to parse templates")
	for _, template := range templates.Templates() {
		m.emailTemplate = template
		err = m.sendNags(nil, []*x509.Certificate{cert})
		test.AssertNotError(t, err, "failed to send nag")
	}
}
Ejemplo n.º 14
0
func main() {

	var err error

	cwd, _ := os.Getwd()
	client := flag.String("client", path.Join(cwd, "client"), "Full path to client directory.")
	addr := flag.String("listen", "127.0.0.1:8088", "Listen address.")

	templates, err = template.ParseGlob(path.Join(*client, "*.html"))
	if err != nil {
		log.Fatal("Failed to load templates: ", err)
	}

	flag.Parse()
	go h.run()
	http.HandleFunc("/", serveClient)
	http.HandleFunc("/realtimetraffic", serveWs)
	http.Handle("/css/", http.FileServer(http.Dir(*client)))
	http.Handle("/scripts/", http.FileServer(http.Dir(*client)))
	http.Handle("/img/", http.FileServer(http.Dir(*client)))
	http.Handle("/favicon.ico", http.FileServer(http.Dir(*client)))

	err = http.ListenAndServe(*addr, nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}

}
Ejemplo n.º 15
0
func init() {
	var err error
	Templates, err = template.ParseGlob("templates/*/*.html")
	if err != nil {
		panic(err)
	}
}
Ejemplo n.º 16
0
// Here we demonstrate loading a set of templates from a directory.
func ExampleTemplate_glob() {
	// Here we create a temporary directory and populate it with our sample
	// template definition files; usually the template files would already
	// exist in some location known to the program.
	dir := createTestDir([]templateFile{
		// T0.tmpl is a plain template file that just invokes T1.
		{"T0.tmpl", `T0 invokes T1: ({{template "T1"}})`},
		// T1.tmpl defines a template, T1 that invokes T2.
		{"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
		// T2.tmpl defines a template T2.
		{"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
	})
	// Clean up after the test; another quirk of running as an example.
	defer os.RemoveAll(dir)

	// pattern is the glob pattern used to find all the template files.
	pattern := filepath.Join(dir, "*.tmpl")

	// Here starts the example proper.
	// T0.tmpl is the first name matched, so it becomes the starting template,
	// the value returned by ParseGlob.
	tmpl := template.Must(template.ParseGlob(pattern))

	err := tmpl.Execute(os.Stdout, nil)
	if err != nil {
		log.Fatalf("template execution: %s", err)
	}
	// Output:
	// T0 invokes T1: (T1 invokes T2: (This is T2))
}
Ejemplo n.º 17
0
func (r Renderer) RenderAll(site *SiteContext, posts []*Post) error {
	templates := template.Must(
		template.ParseGlob(path.Join(r.TemplatePath, "*.html")))

	// ensure the output directory exists
	err := os.MkdirAll(path.Join(r.OutputPath), 0755)
	if err != nil {
		return err
	}

	// copy assets
	cpDir(path.Join(r.TemplatePath, "assets"), path.Join(r.OutputPath, "assets"))

	// make the index page
	index, err := os.Create(path.Join(r.OutputPath, "index.html"))
	if err != nil {
		log.Panicf(err.Error())
	}
	err = templates.ExecuteTemplate(index, "index.html", &IndexContext{site, posts, "Home", ""})

	// gratuitous use of goroutines
	// use a WaitGroup to ensure all goroutines get access to STDOUT
	var wg sync.WaitGroup
	for _, post := range posts {
		wg.Add(1)
		go func(site *SiteContext, post *Post) {
			defer wg.Done()
			pc := &PostContext{site, post, "../"}
			r.RenderPost(pc, templates)
		}(site, post)
	}
	wg.Wait()

	return nil
}
Ejemplo n.º 18
0
func AddTemplGlob(pattern string) {
	var err error
	templates, err = template.ParseGlob(pattern)
	if err != nil {
		log.Println("parse templates failed,", err)
	}
	//templates.ParseFiles("/temps/cover.html")
}
Ejemplo n.º 19
0
func loadTemplates() {
	//Load templates
	tmpl := template.Must(template.ParseGlob("views/*.html"))
	for _, t := range tmpl.Templates() {
		// log.Printf("Template imported: %s", t.Name())
		Templates[t.Name()] = t
	}
}
Ejemplo n.º 20
0
func aatmplMain() error {
	templates := filepath.Join("templates", "*.tmpl")
	tmpl, err := template.ParseGlob(templates)
	if err != nil {
		return err
	}

	// generate cmd/aa2txt/aa2txt.go
	fp, err := os.Create(filepath.Join("cmd", "aa2txt", "aa2txt.go"))
	if err != nil {
		return err
	}
	defer fp.Close()
	err = tmpl.ExecuteTemplate(fp, "aa2txt.tmpl", map[string]string{
		"MainFunc": "toTxt(asciiArt string)",
	})
	if err != nil {
		return err
	}

	// generate example.go
	example := filepath.Join("util", "cmd", "aaexample", "aaexample.go")
	fp, err = os.Create(example)
	if err != nil {
		return err
	}
	defer fp.Close()
	err = tmpl.ExecuteTemplate(fp, "exampleprog.tmpl", map[string]string{
		"MainFunc": "main()",
	})
	if err != nil {
		return err
	}

	// execute example.go and capture output for README.md
	output, err := runExample(example)
	if err != nil {
		return err
	}

	// generate README.md
	fp, err = os.Create("README.md")
	if err != nil {
		return err
	}
	defer fp.Close()
	err = tmpl.ExecuteTemplate(fp, "readme.tmpl", map[string]string{
		"MainFunc": "main()",
		"Output":   output,
		"Usage":    getUsage(),
	})
	if err != nil {
		return err
	}

	return nil
}
Ejemplo n.º 21
0
func render(w http.ResponseWriter, templateName string, data interface{}) {
	if inDevMode {
		views = template.Must(template.ParseGlob("views/[a-z]*.html"))
	}
	err := views.ExecuteTemplate(w, templateName, data)
	if err != nil {
		serverError(w, err)
	}
}
Ejemplo n.º 22
0
func init() {
	t, err := template.ParseGlob("templates/*")
	t.Parse(
		fmt.Sprintf(`{{define "hash"}}%d{{end}}`, time.Now().Unix()),
	)
	if err != nil {
		log.Fatal(err)
	}
	T = template.Must(t, err)
}
Ejemplo n.º 23
0
func NewRouter(routes []Route, logger *Logger) *Router {
	templates, _ := template.ParseGlob("./templates/*.html")
	router := Router{routes: make(map[string]*Route), logger: logger, templates: templates}

	for _, route := range routes {
		router.AddRoute(route.Method, route.Path, &route)
	}

	return &router
}
Ejemplo n.º 24
-1
// buildToc generates the table of contents for the epub file.
func (w *EpubArchive) buildToc(opf Opf) Chapter {
	tmpl := template.Must(template.ParseGlob(templateGlob))
	buf := new(bytes.Buffer)
	err := tmpl.ExecuteTemplate(buf, "toc.xhtml.tpl", opf.RootFiles[0].Manifest)
	if err != nil {
		log.Fatalf("template execution: %s", err)
	}
	toc := Chapter{FileName: "chapters/toc.xhtml",
		Contents: string(buf.Bytes())}
	return toc
}
Ejemplo n.º 25
-1
// Renders current site to html
func Render_Site() error {
	var err error
	filepath.Walk(config.SourceDir, Walker)
	var pages PagesSlice
	for _, dir := range site.Directories {

		readglob := dir + "/*.md"
		var dirfiles, _ = filepath.Glob(readglob)

		// loop through files in directory
		for _, file := range dirfiles {
			//fmt.Println("  File:", file)
			outfile := filepath.Base(file)
			outfile = strings.Replace(outfile, ".md", ".html", 1)

			// read & parse file for parameters
			page := readParseFile(file)
			page.OutFile = dir + "/" + outfile
			// create array of parsed pages
			pages = append(pages, page)
		}
	}
	//fmt.Printf("%v\n", pages)
	layoutsglob := config.TemplateDir + "/*.html"
	_, err = template.ParseGlob(layoutsglob)
	if err != nil {
		PrintErr("Error Parsing Templates: ", err)
		os.Exit(1)
	}

	for _, page := range pages {
		html := applyTemplates(page)
		fmt.Println(page.Url)
		err = WritePage(page, html)
		if err != nil {
			PrintErr("Cant generate site", err)
			os.Exit(1)
		}
	}
	// Generate index listings...
	for _, dir := range site.Directories {
		html, page, _ := getDirectoryListing(dir)
		err = WritePage(page, html)
		if err != nil {
			PrintErr("Error writing index files", err)
			os.Exit(1)
		}
		WriteJson(page, dir)

	}

	return nil

}
Ejemplo n.º 26
-1
func main() {
	// Load the templates.
	tmpl, err := template.ParseGlob("cuckoo.tmpl")
	if err != nil {
		log.Fatal(err)
	}
	tmplTest, err := template.ParseGlob("cuckoo_test.tmpl")
	if err != nil {
		log.Fatal(err)
	}
	tmplBench, err := template.ParseGlob("bench_test.tmpl")
	if err != nil {
		log.Fatal(err)
	}

	// Generate Cuckoo filter types.
	for _, data := range []cData{
		{Name: "S", NumBits: 8, NumBitsFingerprint: 4, Desc: "1 byte per item", ErrRate: 11, MaxInserts: 2},
		{Name: "M", NumBits: 16, NumBitsFingerprint: 8, Desc: "2 bytes per item", ErrRate: 1, MaxInserts: 2},
		{Name: "L", NumBits: 32, NumBitsFingerprint: 16, Desc: "4 bytes per item", ErrRate: 0.005, MaxInserts: 2},
		// similar error rate as bucket 32 / fingerprint 16 with twice the memory footprint
		// {Name: "L", NumBits: 64, NumBitsFingerprint: 16, Desc: "8 bytes per item", ErrRate: 0.005, MaxInserts: 4},
	} {
		log.Printf("Generating %s\n", data.Name)
		// Compute the uint size to hold a fingerprint
		data.NumBitsFingerprintUint = power2(data.NumBitsFingerprint)
		if data.NumBitsFingerprintUint < 8 {
			data.NumBitsFingerprintUint = 8
		}
		genFile(fmt.Sprintf("cuckoo%s.go", data.Name), tmpl, &data)
		genFile(fmt.Sprintf("cuckoo%s_test.go", data.Name), tmplTest, &data)
		genFile(fmt.Sprintf("bench%s_test.go", data.Name), tmplBench, &data)
	}
	log.Println("Running go fmt")
	cmd := exec.Command("go", "fmt")
	cmd.Dir = "."
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		log.Fatal(err)
	}
}
Ejemplo n.º 27
-1
func build() {
	var err error
	t, err = template.ParseGlob("templates/*.t")
	if err != nil {
		log.Fatal(err)
		return
	}
	parseCategories()

	filepath.Walk("posts", func(path string, info os.FileInfo, err error) error {
		if !info.IsDir() && filepath.Ext(path) == ".md" {
			p, err := parsePost(path)
			if err != nil {
				log.Error(err)
				return nil
			}
			var b bytes.Buffer

			if p.HTML != "" {
				b = *bytes.NewBufferString(p.Content)
			} else {
				err = t.ExecuteTemplate(&b, "post.t", p)
				if err != nil {
					log.Error(err)
					return nil
				}
			}

			pages["/"+p.Name] = b
			addPostToCategory(p)
			addPostToFeed(p)
		}
		return nil
	})

	log.Info("create home page")

	var b bytes.Buffer
	err = t.ExecuteTemplate(&b, "index.t", categories)
	log.FatalOnError(err)
	pages["/"] = b

	log.Info("create feeds")
	feed := feed()

	atom, err := feed.ToAtom()
	log.FatalOnError(err)
	pages["/feed"] = *bytes.NewBufferString(atom)

	rss, err := feed.ToRss()
	log.FatalOnError(err)
	pages["/rss"] = *bytes.NewBufferString(rss)
}
Ejemplo n.º 28
-1
// NewTemplatizedEmailerFromGlobs creates a new TemplatizedEmailer, parsing the templates found in the given filepattern globs.
func NewTemplatizedEmailerFromGlobs(textGlob, htmlGlob string, emailer Emailer) (*TemplatizedEmailer, error) {
	textTemplates, err := template.ParseGlob(textGlob)
	if err != nil {
		return nil, err
	}

	htmlTemplates, err := htmltemplate.ParseGlob(htmlGlob)
	if err != nil {
		return nil, err
	}

	return NewTemplatizedEmailerFromTemplates(textTemplates, htmlTemplates, emailer), nil
}
Ejemplo n.º 29
-1
func main() {

	var pattern string
	flag.StringVar(&pattern, "p", "templates/*.html", "template pattern like template/*.html")
	template, err := template.ParseGlob(pattern)
	if err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
	}

	var mainTemplate string
	flag.StringVar(&mainTemplate, "t", "index", "main template like index")
	template.ExecuteTemplate(os.Stdout, mainTemplate, nil)
}
Ejemplo n.º 30
-2
func main() {
	router := mux.NewRouter()
	htmlTemplates = template.Must(template.ParseGlob("templates/*"))
	font = readFont()

	router.HandleFunc("/", homePage)
	router.HandleFunc("/generate", handleForm).Methods("POST")
	router.PathPrefix("/assets").Handler(staticHandler())
	http.Handle("/", router)
	log.Fatal(http.ListenAndServe(":8001", nil))
}