code review 5307066: non-pkg: gofix -r error

doc/codelab/wiki/index.html

 <!-- Codelab: Writing Web Applications -->
 <h2>Introduction</h2>
 
 <p>
 Covered in this codelab:
 </p>
 <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>template</code> package to process HTML templates</li>
@@ skipping 80 matching lines @@
 libraries we will use, as you'll see below.
 </p>
 
 <p>
 The <code>Page</code> struct describes how page data will be stored in memory.·
 But what about persistent storage? We can address that by creating a·
 <code>save</code> method on <code>Page</code>:
 </p>
 
 <pre>
-func (p *Page) save() os.Error {
+func (p *Page) save() error {
         filename := p.Title + &#34;.txt&#34;
         return ioutil.WriteFile(filename, p.Body, 0600)
 }
 </pre>
 
 <p>
 This method's signature reads: "This is a method named <code>save</code> that
 takes as its receiver <code>p</code>, a pointer to <code>Page</code> . It takes
 no parameters, and returns a value of type <code>os.Error</code>."·
 </p>
@@ skipping 46 matching lines @@
 error return value (in essence, assigning the value to nothing).·
 </p>
 
 <p>
 But what happens if <code>ReadFile</code> encounters an error?  For example,
 the file might not exist. We should not ignore such errors.  Let's modify the
 function to return <code>*Page</code> and <code>os.Error</code>.
 </p>
 
 <pre>
-func loadPage(title string) (*Page, os.Error) {
+func loadPage(title string) (*Page, error) {
         filename := title + &#34;.txt&#34;
         body, err := ioutil.ReadFile(filename)
         if err != nil {
                 return nil, err
         }
         return &amp;Page{Title: title, Body: body}, nil
 }
 </pre>
 
 <p>
@@ skipping 459 matching lines @@
 </p>
 
 <p>
 First, let's handle the errors in <code>renderTemplate</code>:
 </p>
 
 <pre>
 func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
         t, err := template.ParseFile(tmpl+&#34;.html&#34;, nil)
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
                 return
         }
         err = t.Execute(w, p)
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
         }
 }
 </pre>
 
 <p>
 The <code>http.Error</code> function sends a specified HTTP response code·
 (in this case "Internal Server Error") and error message.
 Already the decision to put this in a separate function is paying off.
 </p>
 
 <p>
 Now let's fix up <code>saveHandler</code>:
 </p>
 
 <pre>
 func saveHandler(w http.ResponseWriter, r *http.Request) {
         title, err := getTitle(w, r)
         if err != nil {
                 return
         }
         body := r.FormValue(&#34;body&#34;)
         p := &amp;Page{Title: title, Body: []byte(body)}
         err = p.save()
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
                 return
         }
         http.Redirect(w, r, &#34;/view/&#34;+title, http.StatusFound)
 }
 </pre>
 
 <p>
 Any errors that occur during <code>p.save()</code> will be reported·
 to the user.
 </p>
@@ skipping 45 matching lines @@
 
 <p>
 We then modify our <code>renderTemplate</code> function to call·
 the <code>Execute</code> method on the appropriate <code>Template</code> from·
 <code>templates</code>:
 
 <pre>
 func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
         err := templates[tmpl].Execute(w, p)
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
         }
 }
 </pre>
 
 <h2>Validation</h2>
 
 <p>
 As you may have observed, this program has a serious security flaw: a user
 can supply an arbitrary path to be read/written on the server. To mitigate
 this, we can write a function to validate the title with a regular expression.
@@ skipping 15 matching lines @@
 panic if the expression compilation fails, while <code>Compile</code> returns
 an <code>os.Error</code> as a second parameter.·
 </p>
 
 <p>
 Now, let's write a function that extracts the title string from the request·
 URL, and tests it against our <code>TitleValidator</code> expression:
 </p>
 
 <pre>
-func getTitle(w http.ResponseWriter, r *http.Request) (title string, err os.Error) {
+func getTitle(w http.ResponseWriter, r *http.Request) (title string, err error) {
         title = r.URL.Path[lenPath:]
         if !titleValidator.MatchString(title) {
                 http.NotFound(w, r)
-                err = os.NewError(&#34;Invalid Page Title&#34;)
+                err = errors.New(&#34;Invalid Page Title&#34;)
         }
         return
 }
 </pre>
 
 <p>
 If the title is valid, it will be returned along with a <code>nil</code>
 error value.  If the title is invalid, the function will write a·
 "404 Not Found" error to the HTTP connection, and return an error to the·
 handler.·
@@ skipping 31 matching lines @@
 
 func saveHandler(w http.ResponseWriter, r *http.Request) {
         title, err := getTitle(w, r)
         if err != nil {
                 return
         }
         body := r.FormValue(&#34;body&#34;)
         p := &amp;Page{Title: title, Body: []byte(body)}
         err = p.save()
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
                 return
         }
         http.Redirect(w, r, &#34;/view/&#34;+title, http.StatusFound)
 }
 </pre>
 
 <h2>Introducing Function Literals and Closures</h2>
 
 <p>
 Catching the error condition in each handler introduces a lot of repeated code.
@@ skipping 104 matching lines @@
                 p = &amp;Page{Title: title}
         }
         renderTemplate(w, &#34;edit&#34;, p)
 }
 
 func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
         body := r.FormValue(&#34;body&#34;)
         p := &amp;Page{Title: title, Body: []byte(body)}
         err := p.save()
         if err != nil {
-                http.Error(w, err.String(), http.StatusInternalServerError)
+                http.Error(w, err.Error(), http.StatusInternalServerError)
                 return
         }
         http.Redirect(w, r, &#34;/view/&#34;+title, http.StatusFound)
 }
 </pre>
 
 <h2>Try it out!</h2>
 
 <p>
 <a href="final.go">Click here to view the final code listing.</a>
@@ skipping 26 matching lines @@
 <li>Add a handler to make the web root redirect to·
         <code>/view/FrontPage</code>.</li>
 <li>Spruce up the page templates by making them valid HTML and adding some
         CSS rules.</li>
 <li>Implement inter-page linking by converting instances of·
         <code>[PageName]</code> to <br>
         <code>&lt;a href="/view/PageName"&gt;PageName&lt;/a&gt;</code>.
         (hint: you could use <code>regexp.ReplaceAllFunc</code> to do this)
         </li>
 </ul>