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

src/cmd/goinstall/download.go

 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Download remote packages.
 
 package main
 
 import (
         "bytes"
+        "errors"
         "exec"
         "fmt"
         "http"
         "json"
         "os"
         "path/filepath"
         "regexp"
         "runtime"
         "strconv"
         "strings"
@@ skipping 92 matching lines @@
         tagListRe:     regexp.MustCompile("([^ ]+)[^\n]+\n"),
         check:         "info",
         protocols:     []string{"https", "http", "bzr"},
         suffix:        ".bzr",
 }
 
 var vcsList = []*vcs{&git, &hg, &bzr, &svn}
 
 type host struct {
         pattern *regexp.Regexp
-        getVcs  func(repo, path string) (*vcsMatch, os.Error)
+        getVcs  func(repo, path string) (*vcsMatch, error)
 }
 
 var knownHosts = []host{
         {
                 regexp.MustCompile(`^([a-z0-9\-]+\.googlecode\.com/(svn|git|hg))(/[a-z0-9A-Z_.\-/]*)?$`),
                 googleVcs,
         },
         {
                 regexp.MustCompile(`^(github\.com/[a-z0-9A-Z_.\-]+/[a-z0-9A-Z_.\-]+)(/[a-z0-9A-Z_.\-/]*)?$`),
                 githubVcs,
         },
         {
                 regexp.MustCompile(`^(bitbucket\.org/[a-z0-9A-Z_.\-]+/[a-z0-9A-Z_.\-]+)(/[a-z0-9A-Z_.\-/]*)?$`),
                 bitbucketVcs,
         },
         {
                 regexp.MustCompile(`^(launchpad\.net/([a-z0-9A-Z_.\-]+(/[a-z0-9A-Z_.\-]+)?|~[a-z0-9A-Z_.\-]+/(\+junk|[a-z0-9A-Z_.\-]+)/[a-z0-9A-Z_.\-]+))(/[a-z0-9A-Z_.\-/]+)?$`),
                 launchpadVcs,
         },
 }
 
 type vcsMatch struct {
         *vcs
         prefix, repo string
 }
 
-func googleVcs(repo, path string) (*vcsMatch, os.Error) {
+func googleVcs(repo, path string) (*vcsMatch, error) {
         parts := strings.SplitN(repo, "/", 2)
         url := "https://" + repo
         switch parts[1] {
         case "svn":
                 return &vcsMatch{&svn, repo, url}, nil
         case "git":
                 return &vcsMatch{&git, repo, url}, nil
         case "hg":
                 return &vcsMatch{&hg, repo, url}, nil
         }
-        return nil, os.NewError("unsupported googlecode vcs: " + parts[1])
-}
-
-func githubVcs(repo, path string) (*vcsMatch, os.Error) {
+        return nil, errors.New("unsupported googlecode vcs: " + parts[1])
+}
+
+func githubVcs(repo, path string) (*vcsMatch, error) {
         if strings.HasSuffix(repo, ".git") {
-                return nil, os.NewError("path must not include .git suffix")
+                return nil, errors.New("path must not include .git suffix")
         }
         return &vcsMatch{&git, repo, "http://" + repo + ".git"}, nil
 }
 
-func bitbucketVcs(repo, path string) (*vcsMatch, os.Error) {
+func bitbucketVcs(repo, path string) (*vcsMatch, error) {
         const bitbucketApiUrl = "https://api.bitbucket.org/1.0/repositories/"
 
         if strings.HasSuffix(repo, ".git") {
-                return nil, os.NewError("path must not include .git suffix")
+                return nil, errors.New("path must not include .git suffix")
         }
 
         parts := strings.SplitN(repo, "/", 2)
 
         // Ask the bitbucket API what kind of repository this is.
         r, err := http.Get(bitbucketApiUrl + parts[1])
         if err != nil {
                 return nil, fmt.Errorf("error querying BitBucket API: %v", err)
         }
         defer r.Body.Close()
@@ skipping 12 matching lines @@
         }
 
         // Now we should be able to construct a vcsMatch structure
         switch response.Vcs {
         case "git":
                 return &vcsMatch{&git, repo, "http://" + repo + ".git"}, nil
         case "hg":
                 return &vcsMatch{&hg, repo, "http://" + repo}, nil
         }
 
-        return nil, os.NewError("unsupported bitbucket vcs: " + response.Vcs)
-}
-
-func launchpadVcs(repo, path string) (*vcsMatch, os.Error) {
+        return nil, errors.New("unsupported bitbucket vcs: " + response.Vcs)
+}
+
+func launchpadVcs(repo, path string) (*vcsMatch, error) {
         return &vcsMatch{&bzr, repo, "https://" + repo}, nil
 }
 
 // findPublicRepo checks whether pkg is located at one of
 // the supported code hosting sites and, if so, returns a match.
-func findPublicRepo(pkg string) (*vcsMatch, os.Error) {
+func findPublicRepo(pkg string) (*vcsMatch, error) {
         for _, host := range knownHosts {
                 if hm := host.pattern.FindStringSubmatch(pkg); hm != nil {
                         return host.getVcs(hm[1], hm[2])
                 }
         }
         return nil, nil
 }
 
 // findAnyRepo looks for a vcs suffix in pkg (.git, etc) and returns a match.
-func findAnyRepo(pkg string) (*vcsMatch, os.Error) {
+func findAnyRepo(pkg string) (*vcsMatch, error) {
         for _, v := range vcsList {
                 i := strings.Index(pkg+"/", v.suffix+"/")
                 if i < 0 {
                         continue
                 }
                 if !strings.Contains(pkg[:i], "/") {
                         continue // don't match vcs suffix in the host name
                 }
                 if m := v.find(pkg[:i]); m != nil {
                         return m, nil
@@ skipping 27 matching lines @@
                 return false
         }
         parts = strings.Split(parts[0], ".")
         if len(parts) < 2 || len(parts[len(parts)-1]) < 2 {
                 return false
         }
         return true
 }
 
 // download checks out or updates pkg from the remote server.
-func download(pkg, srcDir string) (public bool, err os.Error) {
+func download(pkg, srcDir string) (public bool, err error) {
         if strings.Contains(pkg, "..") {
-                err = os.NewError("invalid path (contains ..)")
+                err = errors.New("invalid path (contains ..)")
                 return
         }
         m, err := findPublicRepo(pkg)
         if err != nil {
                 return
         }
         if m != nil {
                 public = true
         } else {
                 m, err = findAnyRepo(pkg)
                 if err != nil {
                         return
                 }
         }
         if m == nil {
-                err = os.NewError("cannot download: " + pkg)
+                err = errors.New("cannot download: " + pkg)
                 return
         }
         err = m.checkoutRepo(srcDir, m.prefix, m.repo)
         return
 }
 
 // updateRepo gets a list of tags in the repository and
 // checks out the tag closest to the current runtime.Version.
 // If no matching tag is found, it just updates to tip.
-func (v *vcs) updateRepo(dst string) os.Error {
+func (v *vcs) updateRepo(dst string) error {
         if v.tagList == "" || v.tagListRe == nil {
                 // TODO(adg): fix for svn
                 return run(dst, nil, v.cmd, v.update)
         }
 
         // Get tag list.
         stderr := new(bytes.Buffer)
         cmd := exec.Command(v.cmd, v.tagList)
         cmd.Dir = dst
         cmd.Stderr = stderr
@@ skipping 61 matching lines @@
                 }
         }
         return match
 }
 
 // checkoutRepo checks out repo into dst using vcs.
 // It tries to check out (or update, if the dst already
 // exists and -u was specified on the command line)
 // the repository at tag/branch "release".  If there is no
 // such tag or branch, it falls back to the repository tip.
-func (vcs *vcs) checkoutRepo(srcDir, pkgprefix, repo string) os.Error {
+func (vcs *vcs) checkoutRepo(srcDir, pkgprefix, repo string) error {
         dst := filepath.Join(srcDir, filepath.FromSlash(pkgprefix))
         dir, err := os.Stat(filepath.Join(dst, vcs.metadir))
         if err == nil && !dir.IsDirectory() {
-                return os.NewError("not a directory: " + dst)
+                return errors.New("not a directory: " + dst)
         }
         if err != nil {
                 parent, _ := filepath.Split(dst)
                 if err = os.MkdirAll(parent, 0777); err != nil {
                         return err
                 }
                 if err = run(string(filepath.Separator), nil, vcs.cmd, vcs.clone, repo, dst); err != nil {
                         return err
                 }
                 return vcs.updateRepo(dst)
         }
         if *update {
                 // Retrieve new revisions from the remote branch, if the VCS
                 // supports this operation independently (e.g. svn doesn't)
                 if vcs.pull != "" {
                         if vcs.pullForceFlag != "" {
                                 if err = run(dst, nil, vcs.cmd, vcs.pull, vcs.pullForceFlag); err != nil {
                                         return err
                                 }
                         } else if err = run(dst, nil, vcs.cmd, vcs.pull); err != nil {
                                 return err
                         }
                 }
                 // Update to release or latest revision
                 return vcs.updateRepo(dst)
         }
         return nil
 }