Exemple #1
0
func init() {
	ALL_METHODS = []string{GET, HEAD, POST, CONNECT, DELETE, OPTIONS, PUT, TRACE}

	defaultMimeTypes = make(map[string]string)
	defaultMimeTypes[".htm"] = MIME_TYPE_HTML
	defaultMimeTypes[".html"] = MIME_TYPE_HTML
	defaultMimeTypes[".xhtml"] = MIME_TYPE_XHTML_XML
	defaultMimeTypes[".xml"] = MIME_TYPE_XML
	defaultMimeTypes[".css"] = MIME_TYPE_CSS
	defaultMimeTypes[".js"] = MIME_TYPE_JAVASCRIPT
	defaultMimeTypes[".json"] = MIME_TYPE_JSON
	defaultMimeTypes[".jpg"] = MIME_TYPE_JPEG
	defaultMimeTypes[".jpeg"] = MIME_TYPE_JPEG
	defaultMimeTypes[".gif"] = MIME_TYPE_GIF
	defaultMimeTypes[".png"] = MIME_TYPE_PNG
	defaultMimeTypes[".ico"] = MIME_TYPE_ICO
	defaultMimeTypes[".swf"] = MIME_TYPE_SWF
	defaultMimeTypes[".zip"] = MIME_TYPE_ZIP
	defaultMimeTypes[".bz2"] = MIME_TYPE_BZIP2
	defaultMimeTypes[".gz"] = MIME_TYPE_GZ
	defaultMimeTypes[".tar"] = MIME_TYPE_TAR
	defaultMimeTypes[".tgz"] = MIME_TYPE_GZ
	defaultMimeTypes[".htc"] = MIME_TYPE_COMPONENT
	defaultMimeTypes[".manifest"] = MIME_TYPE_CACHE_MANIFEST
	defaultMimeTypes[".svg"] = MIME_TYPE_SVG
	defaultMimeTypes[".txt"] = MIME_TYPE_TEXT_PLAIN
	defaultMimeTypes[".text"] = MIME_TYPE_TEXT_PLAIN
	defaultMimeTypes[".csv"] = MIME_TYPE_CSV

	HTML_DIRECTORY_LISTING_SUCCESS_TEMPLATE, _ = template.New("directory_listing_success").Parse(HTML_DIRECTORY_LISTING_SUCCESS_TEMPLATE_STRING)
	HTML_DIRECTORY_LISTING_ERROR_TEMPLATE, _ = template.New("directory_listing_error").Parse(HTML_DIRECTORY_LISTING_ERROR_TEMPLATE_STRING)
}
Exemple #2
0
func init() {
	rand.Seed(time.Nanoseconds())

	// TODO: This should end up in a configuration file
	schema = &grapher.Schema{FileSchemas: map[string]*grapher.FileSchema{
		"application/x-lightwave-book": &grapher.FileSchema{EntitySchemas: map[string]*grapher.EntitySchema{
			"application/x-lightwave-entity-chapter": &grapher.EntitySchema{FieldSchemas: map[string]*grapher.FieldSchema{
				"after": &grapher.FieldSchema{Type: grapher.TypeEntityBlobRef, ElementType: grapher.TypeNone, Transformation: grapher.TransformationNone},
				"title": &grapher.FieldSchema{Type: grapher.TypeString, ElementType: grapher.TypeNone, Transformation: grapher.TransformationLatest},
				"color": &grapher.FieldSchema{Type: grapher.TypeInt64, ElementType: grapher.TypeNone, Transformation: grapher.TransformationLatest}}},
			"application/x-lightwave-entity-page": &grapher.EntitySchema{FieldSchemas: map[string]*grapher.FieldSchema{
				"after":   &grapher.FieldSchema{Type: grapher.TypeEntityBlobRef, ElementType: grapher.TypeNone, Transformation: grapher.TransformationNone},
				"title":   &grapher.FieldSchema{Type: grapher.TypeString, ElementType: grapher.TypeNone, Transformation: grapher.TransformationLatest},
				"chapter": &grapher.FieldSchema{Type: grapher.TypeEntityBlobRef, ElementType: grapher.TypeNone, Transformation: grapher.TransformationNone},
				"page":    &grapher.FieldSchema{Type: grapher.TypePermaBlobRef, ElementType: grapher.TypeNone, Transformation: grapher.TransformationNone}}}}},
		"application/x-lightwave-page": &grapher.FileSchema{EntitySchemas: map[string]*grapher.EntitySchema{
			"application/x-lightwave-entity-content": &grapher.EntitySchema{FieldSchemas: map[string]*grapher.FieldSchema{
				"layout":   &grapher.FieldSchema{Type: grapher.TypeString, ElementType: grapher.TypeNone, Transformation: grapher.TransformationNone},
				"style":    &grapher.FieldSchema{Type: grapher.TypeMap, ElementType: grapher.TypeNone, Transformation: grapher.TransformationMerge},
				"cssclass": &grapher.FieldSchema{Type: grapher.TypeString, ElementType: grapher.TypeNone, Transformation: grapher.TransformationLatest},
				"text":     &grapher.FieldSchema{Type: grapher.TypeString, ElementType: grapher.TypeNone, Transformation: grapher.TransformationMerge}}}}}}}

	frontPageTmpl = template.New(nil)
	frontPageTmpl.SetDelims("{{", "}}")
	if err := frontPageTmpl.ParseFile("notebook.html"); err != nil {
		frontPageTmplErr = fmt.Errorf("tmpl.ParseFile failed: %v", err)
		return
	}

	appLoginPageTmpl = template.New(nil)
	appLoginPageTmpl.SetDelims("{{", "}}")
	if err := appLoginPageTmpl.ParseFile("applogin.html"); err != nil {
		appLoginPageTmplErr = fmt.Errorf("tmpl.ParseFile failed: %v", err)
		return
	}

	http.HandleFunc("/", handleFrontPage)
	http.HandleFunc("/private/submit", handleSubmit)
	http.HandleFunc("/private/open", handleOpen)
	http.HandleFunc("/private/close", handleClose)
	http.HandleFunc("/private/listpermas", handleListPermas)
	http.HandleFunc("/private/listinbox", handleListInbox)
	http.HandleFunc("/private/listunread", handleListUnread)
	http.HandleFunc("/private/invitebymail", handleInviteByMail)
	http.HandleFunc("/private/inboxitem", handleInboxItem)
	http.HandleFunc("/private/markasread", handleMarkAsRead)
	http.HandleFunc("/private/markasarchived", handleMarkAsArchived)
	http.HandleFunc("/signup", handleSignup)
	http.HandleFunc("/logout", handleLogout)
	http.HandleFunc("/login", handleLogin)
	http.HandleFunc("/applogin", handleAppLogin)

	http.HandleFunc("/internal/notify", handleDelayedNotify)

	http.HandleFunc("/_ah/channel/connected/", handleConnect)
	http.HandleFunc("/_ah/channel/disconnected/", handleDisconnect)

	//  http.HandleFunc("/import", handleImport)
}
Exemple #3
0
func init() {
	BrowseT = template.New(nil)
	BrowseT.SetDelims("{{", "}}")
	BrowseT.ParseFile(BrowseTemplatePath)
	BrowseChooseT = template.New(nil)
	BrowseChooseT.SetDelims("{{", "}}")
	BrowseChooseT.ParseFile(BrowseChooseTemplatePath)
}
Exemple #4
0
func main() {
	t := make(map[string][]Template)
	v := visitor{t}

	filepath.Walk(HtmlDir, &v, nil)

	indexBinder := IndexBinder{make([]Package, 0), make([]Template, 0)}

	for packagePath, templates := range v.Templates {

		filename := packagePath[strings.LastIndex(packagePath, "/")+1:]

		binder := Binder{filename, templates}

		temp := template.New("")

		p, err := temp.Parse(getTemplate())

		if err != nil {
			fmt.Println("Error!", err.String())
			return
		}
		htmlDirWithoutSlash := HtmlDir
		if strings.HasSuffix(htmlDirWithoutSlash, "/") {
			htmlDirWithoutSlash = htmlDirWithoutSlash[0 : len(htmlDirWithoutSlash)-1]
		}
		htmlDirWithoutBaseDir := htmlDirWithoutSlash[0:strings.LastIndex(htmlDirWithoutSlash, "/")]
		fullFilename := fmt.Sprint(htmlDirWithoutBaseDir, "/", packagePath, "/", filename, ".go")
		fmt.Println("fullFilename: ", fullFilename)
		f, _ := os.Create(fullFilename)
		defer f.Close()

		p.Execute(f, binder)

		indexBinder.Packages = append(indexBinder.Packages, Package{PackageName: filename, PackagePath: packagePath, PackagePathUnderscores: strings.Replace(packagePath, "/", "_", -1)})

		for _, template := range templates {
			indexBinder.Templates = append(indexBinder.Templates, template)
		}
	}

	tempIndex := template.New("")

	tempIndexParsed, err := tempIndex.Parse(getTemplateIndex())

	if err != nil {
		fmt.Println("Error!", err.String())
		return
	}
	fIndex, _ := os.Create(IndexFile)
	defer fIndex.Close()

	tempIndexParsed.Execute(fIndex, indexBinder)

	fmt.Println("Done!!")

}
Exemple #5
0
func generateRouter() {
	//mkdir for the initiator
	err := os.MkdirAll(*TargetFullPath+"/router/", 0755)
	if err != nil {
		fmt.Println("Unable to create directory, ", err.String())
	}
	f, err := os.Create(*TargetFullPath + "/router/" + "router.go")
	if err != nil {
		fmt.Println(err.String())
	}
	defer f.Close()
	var templ *template.Template
	templ = template.New(nil)
	templ.SetDelims("<%", "%>")
	err = templ.Parse(routerTemplate)
	if err != nil {
		fmt.Println(err.String())
	}
	err = templ.Execute(f, map[string]interface{}{
		"PackageName": *PackageName,
		"ServiceName": *ServiceName,
	})

	if err != nil {
		fmt.Println(err.String())
	}
}
Exemple #6
0
func init() {
	chatTempl = template.New(nil)
	chatTempl.SetDelims("«", "»")
	if err := chatTempl.Parse(chatStr); err != nil {
		panic("template error: " + err.String())
	}
}
Exemple #7
0
func parse(name, s string) *template.Template {
	t, err := template.New(name).Parse(s)
	if err != nil {
		panic(fmt.Sprintf("%q: %s", name, err))
	}
	return t
}
Exemple #8
0
func ShowErrors(templateString string) Middleware {
	if templateString == "" {
		templateString = `
      <html>
      <body>
        <p>
          {{.Error|html}}
        </p>
      </body>
      </html>
    `
	}

	errorTemplate := template.Must(template.New("error").Parse(templateString))

	return func(env Env, app App) (status Status, headers Headers, body Body) {
		defer func() {
			if err := recover(); err != nil {
				buffer := bytes.NewBufferString("")
				errorTemplate.Execute(buffer, struct{ Error string }{fmt.Sprintf("%s", err)})
				status = 500
				headers = Headers{}
				body = Body(buffer.String())
			}
		}()

		return app(env)
	}
}
Exemple #9
0
func init() {
	homeTempl = template.New("")
	//homeTempl.SetDelims("<<", ">>")
	if _, err := homeTempl.Parse(homeStr); err != nil {
		panic("template error: " + err.String())
	}
}
Exemple #10
0
func init() {
	homeTempl = template.New(nil)
	homeTempl.SetDelims("<<", ">>")
	if err := homeTempl.ParseFile("index.html"); err != nil {
		panic("template error: " + err.String())
	}
}
Exemple #11
0
// articleJSON handles generates the JSON of a specified Article struct. This is
// used as part of the admin manager, to be able to preview and edit the articles
// with JSON.
func articleJSON(w http.ResponseWriter, r *http.Request) {
	// Sanity check to ensure that at least /some/ sort of ID was given
	path := strings.Split(r.URL.Path, "/")
	if len(path) < 4 || path[3] == "" {
		errorGenerator(w, "No Article ID provided", 404)
		return
	}
	// Fetch Article struct based on ID given
	c := appengine.NewContext(r)
	a, err := getArticle(c, path[3])
	check(err)

	// Generate JSON via the template. Can't use the JSON marshaller because we
	// don't want to represent the ShortBody & Body as JSON-encoded []bytes, but
	// as JSON-escaped strings. The template function is also provided with a
	// special function to escape the ShortBody & Body for JSON representation.
	t := template.New("articleJSON")
	t.Funcs(template.FuncMap{"json": escapeForJSON})
	t, err = t.ParseFile("templates/article.json")
	check(err)

	// Execute the template, using the Article struct as a source
	err = t.Execute(w, a)
	check(err)
}
Exemple #12
0
// articlesIndex is the handler for the site's index page.
// It shows up to the last 10 article summaries (all public info except
// for the Body) on a single page.
func articlesIndex(w http.ResponseWriter, r *http.Request) {
	// Get the user-entered offset, or default to a zero offset.
	offsetS := r.FormValue("Page")
	var offset int
	if len(offsetS) > 0 {
		offset64, err := strconv.Btoi64(offsetS, 10)
		check(err)
		offset = int(offset64)
	} else {
		offset = 0
	}

	// Fetch public data from datastore, up to 10, with offset `offset * 10`
	c := appengine.NewContext(r)
	q := datastore.NewQuery("Article").Order("-Date").Filter("Public =", true).Limit(10).Offset(10 * offset)
	a := make([]Article, 0, 10)
	_, err := q.GetAll(c, &a)
	check(err)

	// Prepares the `indexTemplate.html` template
	t := template.New("index")
	t, err = t.ParseFile("templates/indexTemplate.html")
	check(err)

	// Executes the template, providing the data gathered from the datastore
	err = t.Execute(w, a)
	check(err)
}
Exemple #13
0
func init() {
	homeTempl = template.New(nil)
	homeTempl.SetDelims("«", "»")
	if err := homeTempl.Parse(homeStr2); err != nil {
		panic("template error: " + err.String())
	}
}
Exemple #14
0
// Add adds a given template string to the template manager.
// If any errors occur, err will be non-nil.
func (m *Manager) add(s string, id string, mustParse bool) (t *Template,
	err os.Error) {
	tt := template.New(m.fmap)
	tt.SetDelims(m.ldelim, m.rdelim)

	// Parse the template.
	if mustParse {
		err := tt.Parse(s)
		if err != nil {
			panic(err)
		}
	} else {
		err := tt.Parse(s)
		if err != nil {
			return
		}
	}

	t = &Template{
		m:     m,
		cache: tt}

	// Add template to the manager.
	m.tStrings[id] = t
	return
}
Exemple #15
0
func TestAutoesc(t *testing.T) {
	for _, testCase := range testCases {
		name := testCase.name
		tmpl := template.New(name)
		tmpl, err := tmpl.Parse(testCase.input)
		if err != nil {
			t.Errorf("%s: failed to parse template: %s", name, err)
			continue
		}

		Escape(tmpl)

		buffer := new(bytes.Buffer)

		err = tmpl.Execute(buffer, testData)
		if err != nil {
			t.Errorf("%s: template execution failed: %s", name, err)
			continue
		}

		output := testCase.output
		actual := buffer.String()
		if output != actual {
			t.Errorf("%s: escaped output: %q != %q",
				name, output, actual)
		}
	}
}
Exemple #16
0
func parseTemplate(filename string) *Template {
	return &Template{
		t: template.Must(template.New(filename).
			Funcs(template.FuncMap{"item": itemFormatter}).
			ParseFile(path.Join("template", filename))),
		mimeType: mime.TypeByExtension(path.Ext(filename))}
}
Exemple #17
0
/*
 * Run the program
 *
 * Usage:
 *		./ls [args] directory_name
 *
 * 		possible args:
 *		-R: go through directories recursively
 *		-n: print with information
 *		-t: sort files by modification time
 *
 *		if no arguments are getting, print out alphabetically with 1 file
 *		per line
 */
func main() {
	var R *bool
	var n *bool
	var t *bool

	R = flag.Bool("R", false, "go through directories recursively")
	n = flag.Bool("n", false, "print with information")
	t = flag.Bool("t", false, "sort files by modification time")
	flag.Parse()

	args := flag.Args()
	if len(args) == 0 {
		args = []string{"./"}
	}
	defer func() {
		if r := recover(); r != nil {
			fmt.Fprintln(os.Stderr, "Invalid Arguments")
		}
	}()

	temp := template.Must(template.New("ls").Parse("{{.Mode}} {{printf `%3d` .Nlink}} {{.Uid}}  {{.Gid}}  {{printf `%7d` .Size}} {{.Mtime}}  {{.Name}}\n"))

	for _, arg := range args {
		if data, error := ls.Ls(arg, *R, *t); error == nil {
			path := data[0][0].Name
			if strings.HasSuffix(path, "/") {
				path = path[0 : len(path)-1]
			}
			printFiles(flag.NArg(), data, path, n, temp)
		} else {
			fmt.Fprintln(os.Stderr, "File or directory not found")
		}
	}
}
Exemple #18
0
// escapeTree escapes the named template starting in the given context as
// necessary and returns its output context.
func (e *escaper) escapeTree(c context, name string, line int) (context, string) {
	// Mangle the template name with the input context to produce a reliable
	// identifier.
	dname := c.mangle(name)
	e.called[dname] = true
	if out, ok := e.output[dname]; ok {
		// Already escaped.
		return out, dname
	}
	t := e.template(name)
	if t == nil {
		return context{
			state: stateError,
			err:   errorf(ErrNoSuchTemplate, line, "no such template %s", name),
		}, dname
	}
	if dname != name {
		// Use any template derived during an earlier call to EscapeSet
		// with different top level templates, or clone if necessary.
		dt := e.template(dname)
		if dt == nil {
			dt = template.New(dname)
			dt.Tree = &parse.Tree{Name: dname, Root: cloneList(t.Root)}
			e.derived[dname] = dt
		}
		t = dt
	}
	return e.computeOutCtx(c, t), dname
}
Exemple #19
0
// articleHandler is the handler for /article/* links.
// It is passed an ArticleID by the user, which is then fetched from
// the datastore and displayed using the articleTemplate.html template
func articleHandler(w http.ResponseWriter, r *http.Request) {
	path := strings.Split(r.URL.Path, "/")

	// Ensure there's at least 3 elements long, with the third element
	// not being an empty string
	if len(path) < 3 || path[2] == "" {
		errorGenerator(w, "No Article ID provided", 404)
		return
	}
	c := appengine.NewContext(r)
	a, err := getArticle(c, path[2])

	// If there was an error, give special error if the ArticleID was
	// missing from the datastore, otherwise use normal error path
	if err != nil {
		if err == datastore.ErrNoSuchEntity {
			// Handle invalid IDs in a special manner.
			errorGenerator(w, "Article not found", 404)
			return
		} else {
			// Some other error must be present, so use default handler
			check(err)
		}
	}

	// Create the article template
	t := template.New("article")
	t, err = t.ParseFile("templates/articleTemplate.html")
	check(err)

	// Execute the article template, populated with the Article struct
	err = t.Execute(w, a)
	check(err)
}
Exemple #20
0
func init() {
	mainTemplate = template.New(template.FormatterMap{})
	mainTemplate.SetDelims("{{", "}}")
	if err := mainTemplate.Parse(rawTemplate); err != nil {
		panic("synthesizer: bad template: " + err.String())
	}
}
Exemple #21
0
func TestEscapeErrorsNotIgnorable(t *testing.T) {
	var b bytes.Buffer
	tmpl := template.Must(template.New("dangerous").Parse("<a"))
	Escape(tmpl)
	err := tmpl.Execute(&b, nil)
	expectExecuteFailure(t, &b, err)
}
Exemple #22
0
func init() {
	http.HandleFunc("/", frontPageHandler)
	http.HandleFunc("/tiles", tileHandler)

	for i := range color {
		// Use a broader range of color for low intensities.
		if i < 255/10 {
			color[i] = image.RGBAColor{uint8(i * 10), 0, 0, 0xFF}
		} else {
			color[i] = image.RGBAColor{0xFF, 0, uint8(i - 255/10), 0xFF}
		}
	}

	tmpl := template.New(nil)
	tmpl.SetDelims("{{", "}}")
	if err := tmpl.ParseFile("map.html"); err != nil {
		frontPage = []byte("tmpl.ParseFile failed: " + err.String())
		return
	}
	b := new(bytes.Buffer)
	data := map[string]interface{}{
		"InProd": !appengine.IsDevAppServer(),
	}
	if err := tmpl.Execute(b, data); err != nil {
		frontPage = []byte("tmpl.Execute failed: " + err.String())
		return
	}
	frontPage = b.Bytes()
}
Exemple #23
0
func handler(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	htmltemplate := template.Must(template.New("html").Parse(templateHTML))
	err := htmltemplate.Execute(w, name)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
	}
}
Exemple #24
0
func init() {
	frontPage = template.New(nil)
	frontPage.SetDelims("«", "»")
	if err := frontPage.Parse(frontPageText); err != nil {
		panic(err)
	}
	output = template.MustParse(outputText, nil)
}
Exemple #25
0
func parse(s string) *template.Template {
	t := template.New(nil)
	t.SetDelims("〈", "〉")
	if err := t.Parse(s); err != nil {
		panic(s)
	}
	return t
}
Exemple #26
0
func ParseTemp(file string) {
	mainTemplate = template.New(nil)
	mainTemplate.SetDelims("{{", "}}")
	if err := mainTemplate.ParseFile(file); err != nil {
		mainTemplateErr = fmt.Errorf("tmpl.ParseFile failed: %v", err)
		return
	}
}
Exemple #27
0
func init() {
	EditorT = template.New(nil)
	EditorT.SetDelims("{{", "}}")
	EditorT.ParseFile(EditorTemplatePath)

	BuildBarT = template.New(nil)
	BuildBarT.SetDelims("{{", "}}")
	BuildBarT.ParseFile(BuildBarTemplatePath)

	PkgInfoT = template.New(nil)
	PkgInfoT.SetDelims("{{", "}}")
	PkgInfoT.ParseFile(PkgInfoTemplatePath)

	BuildT = template.New(nil)
	BuildT.SetDelims("{{", "}}")
	BuildT.ParseFile(BuildTemplatePath)
}
Exemple #28
0
func main() {
	chatTempl = template.Must(template.New("chat").Parse(chatStr))
	go hub()
	server.Run(":8080",
		web.NewRouter().
			Register("/", "GET", chatFrameHandler).
			Register("/ws", "GET", chatWsHandler))
}
Exemple #29
0
func BenchmarkEscapedExecute(b *testing.B) {
	tmpl := template.Must(Escape(template.Must(template.New("t").Parse(`<a onclick="alert('{{.}}')">{{.}}</a>`))))
	var buf bytes.Buffer
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		tmpl.Execute(&buf, "foo & 'bar' & baz")
		buf.Reset()
	}
}
Exemple #30
0
func init() {
	for _, name := range []string{"500", "404", "report"} {
		tmpl := template.Must(template.New(name).ParseFile("jshint/templates/" + name + ".html"))
		templates[name] = tmpl
	}

	http.HandleFunc("/reports/save/", save)
	http.HandleFunc("/reports/", show)
	http.HandleFunc("/", notFound)
}