qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-21 20:04:44 -07:00
Code Releases Activity

doc/codelab: use new template package

Browse Source 
R=golang-dev, r
CC=golang-dev
https://golang.org/cl/4897048
This commit is contained in:
Andrew Gerrand 2011-08-18 10:38:08 +10:00
parent 0f801ff81e
commit b67b72da43
9 changed files with 77 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/codelab/wiki/edit.html
View File

@ -1,6 +1,6 @@
<h1>Editing {Title}</h1>
<h1>Editing {{.Title |html}}</h1>
<form action="/save/{Title}" method="POST">
<div><textarea name="body" rows="20" cols="80">{Body|html}</textarea></div>
<form action="/save/{{.Title |html}}" method="POST">
<div><textarea name="body" rows="20" cols="80">{{printf "%s" .Body |html}}</textarea></div>
<div><input type="submit" value="Save"></div>
</form>

4
doc/codelab/wiki/final-noclosure.go
View File

@ -3,9 +3,9 @@ package main
import (
"http"
"io/ioutil"
"old/template"
"os"
"regexp"
"template"
)
type Page struct {
@ -68,7 +68,7 @@ func saveHandler(w http.ResponseWriter, r *http.Request) {
}
func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
t, err := template.ParseFile(tmpl+".html", nil)
t, err := template.ParseFile(tmpl+".html")
if err != nil {
http.Error(w, err.String(), http.StatusInternalServerError)
return

6
doc/codelab/wiki/final-noerror.go
View File

@ -3,8 +3,8 @@ package main
import (
"http"
"io/ioutil"
"old/template"
"os"
"template"
)
type Page struct {
@ -34,14 +34,14 @@ func editHandler(w http.ResponseWriter, r *http.Request) {
if err != nil {
p = &Page{Title: title}
}
t, _ := template.ParseFile("edit.html", nil)
t, _ := template.ParseFile("edit.html")
t.Execute(w, p)
}
func viewHandler(w http.ResponseWriter, r *http.Request) {
title := r.URL.Path[lenPath:]
p, _ := loadPage(title)
t, _ := template.ParseFile("view.html", nil)
t, _ := template.ParseFile("view.html")
t.Execute(w, p)
}

5
doc/codelab/wiki/final.go
View File

@ -3,9 +3,9 @@ package main
import (
"http"
"io/ioutil"
"old/template"
"os"
"regexp"
"template"
)
type Page struct {
@ -59,7 +59,8 @@ var templates = make(map[string]*template.Template)
func init() {
for _, tmpl := range []string{"edit", "view"} {
templates[tmpl] = template.MustParseFile(tmpl+".html", nil)
t := template.Must(template.ParseFile(tmpl+".html"))
templates[tmpl] = t
}
}

4
doc/codelab/wiki/htmlify.go
View File

@ -1,12 +1,12 @@
package main
import (
"old/template"
"template"
"os"
"io/ioutil"
)
func main() {
b, _ := ioutil.ReadAll(os.Stdin)
template.HTMLFormatter(os.Stdout, "", b)
template.HTMLEscape(os.Stdout, b)
}

68
doc/codelab/wiki/index.html
View File

@ -7,7 +7,7 @@ Covered in this codelab:
<ul>
<li>Creating a data structure with load and save methods</li>
<li>Using the <code>http</code> package to build web applications
<li>Using the <code>old/template</code> package to process HTML templates</li>
<li>Using the <code>template</code> package to process HTML templates</li>
<li>Using the <code>regexp</code> package to validate user input</li>
<li>Using closures</li>
</ul>
@ -426,27 +426,27 @@ This function will work fine, but all that hard-coded HTML is ugly.
Of course, there is a better way.
</p>
<h2>The <code>old/template</code> package</h2>
<h2>The <code>template</code> package</h2>
<p>
The <code>old/template</code> package is part of the Go standard library.
The <code>template</code> package is part of the Go standard library.
(A new template package is coming; this code lab will be updated soon.)
We can
use <code>old/template</code> to keep the HTML in a separate file, allowing
use <code>template</code> to keep the HTML in a separate file, allowing
us to change the layout of our edit page without modifying the underlying Go
code.
</p>
<p>
First, we must add <code>old/template</code> to the list of imports:
First, we must add <code>template</code> to the list of imports:
</p>
<pre>
import (
"http"
"io/ioutil"
<b>"old/template"</b>
"os"
<b>"template"</b>
)
</pre>
@ -456,10 +456,10 @@ Open a new file named <code>edit.html</code>, and add the following lines:
</p>
<pre>
&lt;h1&gt;Editing {Title}&lt;/h1&gt;
&lt;h1&gt;Editing {{.Title |html}}&lt;/h1&gt;
&lt;form action=&#34;/save/{Title}&#34; method=&#34;POST&#34;&gt;
&lt;div&gt;&lt;textarea name=&#34;body&#34; rows=&#34;20&#34; cols=&#34;80&#34;&gt;{Body|html}&lt;/textarea&gt;&lt;/div&gt;
&lt;form action=&#34;/save/{{.Title |html}}&#34; method=&#34;POST&#34;&gt;
&lt;div&gt;&lt;textarea name=&#34;body&#34; rows=&#34;20&#34; cols=&#34;80&#34;&gt;{{printf &#34;%s&#34; .Body |html}}&lt;/textarea&gt;&lt;/div&gt;
&lt;div&gt;&lt;input type=&#34;submit&#34; value=&#34;Save&#34;&gt;&lt;/div&gt;
&lt;/form&gt;
</pre>
@ -476,7 +476,7 @@ func editHandler(w http.ResponseWriter, r *http.Request) {
if err != nil {
p = &amp;Page{Title: title}
}
t, _ := template.ParseFile(&#34;edit.html&#34;, nil)
t, _ := template.ParseFile(&#34;edit.html&#34;)
t.Execute(w, p)
}
</pre>
@ -487,19 +487,21 @@ The function <code>template.ParseFile</code> will read the contents of
</p>
<p>
The method <code>t.Execute</code> replaces all occurrences of
<code>{Title}</code> and <code>{Body}</code> with the values of
<code>p.Title</code> and <code>p.Body</code>, and writes the resultant
HTML to the <code>http.ResponseWriter</code>.
The method <code>t.Execute</code> executes the template, writing the
generated HTML to the <code>http.ResponseWriter</code>.
The <code>.Title</code> and <code>.Body</code> dotted identifiers refer to
<code>p.Title</code> and <code>p.Body</code>.
</p>
<p>
Note that we've used <code>{Body|html}</code> in the above template.
The <code>|html</code> part asks the template engine to pass the value
<code>Body</code> through the <code>html</code> formatter before outputting it,
which escapes HTML characters (such as replacing <code>&gt;</code> with
<code>&amp;gt;</code>).
This will prevent user data from corrupting the form HTML.
Template directives are enclosed in double curly braces.
The <code>printf "%s" .Body</code> instruction is a function call
that outputs <code>.Body</code> as a string instead of a stream of bytes,
the same as a call to <code>fmt.Printf</code>.
The <code>|html</code> part of each directive pipes the value through the
<code>html</code> formatter before outputting it, which escapes HTML
characters (such as replacing <code>&gt;</code> with <code>&amp;gt;</code>),
preventing user data from corrupting the form HTML.
</p>
<p>
@ -513,11 +515,11 @@ While we're working with templates, let's create a template for our
</p>
<pre>
&lt;h1&gt;{Title}&lt;/h1&gt;
&lt;h1&gt;{{.Title |html}}&lt;/h1&gt;
&lt;p&gt;[&lt;a href=&#34;/edit/{Title}&#34;&gt;edit&lt;/a&gt;]&lt;/p&gt;
&lt;p&gt;[&lt;a href=&#34;/edit/{{.Title |html}}&#34;&gt;edit&lt;/a&gt;]&lt;/p&gt;
&lt;div&gt;{Body}&lt;/div&gt;
&lt;div&gt;{{printf &#34;%s&#34; .Body |html}}&lt;/div&gt;
</pre>
<p>
@ -528,7 +530,7 @@ Modify <code>viewHandler</code> accordingly:
func viewHandler(w http.ResponseWriter, r *http.Request) {
title := r.URL.Path[lenPath:]
p, _ := loadPage(title)
t, _ := template.ParseFile(&#34;view.html&#34;, nil)
t, _ := template.ParseFile(&#34;view.html&#34;)
t.Execute(w, p)
}
</pre>
@ -708,16 +710,17 @@ var templates = make(map[string]*template.Template)
<p>
Then we create an <code>init</code> function, which will be called before
<code>main</code> at program initialization. The function
<code>template.MustParseFile</code> is a convenience wrapper around
<code>ParseFile</code> that does not return an error code; instead, it panics
if an error is encountered. A panic is appropriate here; if the templates can't
be loaded the only sensible thing to do is exit the program.
<code>template.Must</code> is a convenience wrapper that panics when passed a
non-nil <code>os.Error</code> value, and otherwise returns the
<code>*Template</code> unaltered. A panic is appropriate here; if the templates
can't be loaded the only sensible thing to do is exit the program.
</p>
<pre>
func init() {
for _, tmpl := range []string{&#34;edit&#34;, &#34;view&#34;} {
templates[tmpl] = template.MustParseFile(tmpl+&#34;.html&#34;, nil)
t := template.Must(template.ParseFile(tmpl + &#34;.html&#34;))
templates[tmpl] = t
}
}
</pre>
@ -763,10 +766,9 @@ var titleValidator = regexp.MustCompile(&#34;^[a-zA-Z0-9]+$&#34;)
<p>
The function <code>regexp.MustCompile</code> will parse and compile the
regular expression, and return a <code>regexp.Regexp</code>.
<code>MustCompile</code>, like <code>template.MustParseFile</code>,
is distinct from <code>Compile</code> in that it will panic if
the expression compilation fails, while <code>Compile</code> returns an
<code>os.Error</code> as a second parameter.
<code>MustCompile</code> is distinct from <code>Compile</code> in that it will
panic if the expression compilation fails, while <code>Compile</code> returns
an <code>os.Error</code> as a second parameter.
</p>
<p>

2
doc/codelab/wiki/srcextract.go
View File

@ -8,7 +8,7 @@ import (
"go/ast"
"go/token"
"log"
"old/template"
"template"
"os"
)

6
doc/codelab/wiki/view.html
View File

@ -1,5 +1,5 @@
<h1>{Title}</h1>
<h1>{{.Title |html}}</h1>
<p>[<a href="/edit/{Title}">edit</a>]</p>
<p>[<a href="/edit/{{.Title |html}}">edit</a>]</p>
<div>{Body}</div>
<div>{{printf "%s" .Body |html}}</div>

49
doc/codelab/wiki/wiki.html
View File

@ -7,7 +7,7 @@ Covered in this codelab:
<ul>
<li>Creating a data structure with load and save methods</li>
<li>Using the <code>http</code> package to build web applications
<li>Using the <code>old/template</code> package to process HTML templates</li>
<li>Using the <code>template</code> package to process HTML templates</li>
<li>Using the <code>regexp</code> package to validate user input</li>
<li>Using closures</li>
</ul>
@ -366,27 +366,27 @@ This function will work fine, but all that hard-coded HTML is ugly.
Of course, there is a better way.
</p>
<h2>The <code>old/template</code> package</h2>
<h2>The <code>template</code> package</h2>
<p>
The <code>old/template</code> package is part of the Go standard library.
The <code>template</code> package is part of the Go standard library.
(A new template package is coming; this code lab will be updated soon.)
We can
use <code>old/template</code> to keep the HTML in a separate file, allowing
use <code>template</code> to keep the HTML in a separate file, allowing
us to change the layout of our edit page without modifying the underlying Go
code.
</p>
<p>
First, we must add <code>old/template</code> to the list of imports:
First, we must add <code>template</code> to the list of imports:
</p>
<pre>
import (
"http"
"io/ioutil"
<b>"old/template"</b>
"os"
<b>"template"</b>
)
</pre>
@ -414,19 +414,21 @@ The function <code>template.ParseFile</code> will read the contents of
</p>
<p>
The method <code>t.Execute</code> replaces all occurrences of
<code>{Title}</code> and <code>{Body}</code> with the values of
<code>p.Title</code> and <code>p.Body</code>, and writes the resultant
HTML to the <code>http.ResponseWriter</code>.
The method <code>t.Execute</code> executes the template, writing the
generated HTML to the <code>http.ResponseWriter</code>.
The <code>.Title</code> and <code>.Body</code> dotted identifiers refer to
<code>p.Title</code> and <code>p.Body</code>.
</p>
<p>
Note that we've used <code>{Body|html}</code> in the above template.
The <code>|html</code> part asks the template engine to pass the value
<code>Body</code> through the <code>html</code> formatter before outputting it,
which escapes HTML characters (such as replacing <code>&gt;</code> with
<code>&amp;gt;</code>).
This will prevent user data from corrupting the form HTML.
Template directives are enclosed in double curly braces.
The <code>printf "%s" .Body</code> instruction is a function call
that outputs <code>.Body</code> as a string instead of a stream of bytes,
the same as a call to <code>fmt.Printf</code>.
The <code>|html</code> part of each directive pipes the value through the
<code>html</code> formatter before outputting it, which escapes HTML
characters (such as replacing <code>&gt;</code> with <code>&amp;gt;</code>),
preventing user data from corrupting the form HTML.
</p>
<p>
@ -572,10 +574,10 @@ our <code>*Template</code> values, keyed by <code>string</code>
<p>
Then we create an <code>init</code> function, which will be called before
<code>main</code> at program initialization. The function
<code>template.MustParseFile</code> is a convenience wrapper around
<code>ParseFile</code> that does not return an error code; instead, it panics
if an error is encountered. A panic is appropriate here; if the templates can't
be loaded the only sensible thing to do is exit the program.
<code>template.Must</code> is a convenience wrapper that panics when passed a
non-nil <code>os.Error</code> value, and otherwise returns the
<code>*Template</code> unaltered. A panic is appropriate here; if the templates
can't be loaded the only sensible thing to do is exit the program.
</p>
<pre>
@ -618,10 +620,9 @@ Then we can create a global variable to store our validation regexp:
<p>
The function <code>regexp.MustCompile</code> will parse and compile the
regular expression, and return a <code>regexp.Regexp</code>.
<code>MustCompile</code>, like <code>template.MustParseFile</code>,
is distinct from <code>Compile</code> in that it will panic if
the expression compilation fails, while <code>Compile</code> returns an
<code>os.Error</code> as a second parameter.
<code>MustCompile</code> is distinct from <code>Compile</code> in that it will
panic if the expression compilation fails, while <code>Compile</code> returns
an <code>os.Error</code> as a second parameter.
</p>
<p>