code review 6453094: godoc: adjust import path for directories with multiple...

src/cmd/godoc/godoc.go

 // Copyright 2009 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.
 
 package main
 
 import (
         "bytes"
         "encoding/json"
         "flag"
@@ skipping 792 matching lines @@
 func remoteSearchURL(query string, html bool) string {
         s := "/search?m=text&q="
         if html {
                 s = "/search?q="
         }
         return s + url.QueryEscape(query)
 }
 
 type PageInfo struct {
         Dirname  string         // directory containing the package
-        PList    []string       // list of package names found
         FSet     *token.FileSet // corresponding file set
         PAst     *ast.File      // nil if no single AST with package exports
         PDoc     *doc.Package   // nil if no single package documentation
         Examples []*doc.Example // nil if no example code
         Dirs     *DirList       // nil if no directory information
         DirTime  time.Time      // directory time stamp
         DirFlat  bool           // if set, show directory in a flat (non-indented) manner
         IsPkg    bool           // false if this is not documenting a real package
         Err      error          // I/O error or nil
 }
@@ skipping 45 matching lines @@
 }
 
 // getPageInfo returns the PageInfo for a package directory abspath. If the
 // parameter genAST is set, an AST containing only the package exports is
 // computed (PageInfo.PAst), otherwise package documentation (PageInfo.Doc)
 // is extracted from the AST. If there is no corresponding package in the
 // directory, PageInfo.PAst and PageInfo.PDoc are nil. If there are no sub-
 // directories, PageInfo.Dirs is nil. If a directory read error occurred,
 // PageInfo.Err is set to the respective error but the error is not logged.
 //
-func (h *docServer) getPageInfo(abspath, relpath, pkgname string, mode PageInfoMode) PageInfo {
+func (h *docServer) getPageInfo(abspath, relpath string, mode PageInfoMode) PageInfo {
         var pkgFiles []string
 
-        // If we're showing the default package, restrict to the ones
+        // Restrict to the package files
         // that would be used when building the package on this
         // system.  This makes sure that if there are separate
         // implementations for, say, Windows vs Unix, we don't
         // jumble them all together.
-        if pkgname == "" {
-                // Note: Uses current binary's GOOS/GOARCH.
-                // To use different pair, such as if we allowed the user
-                // to choose, set ctxt.GOOS and ctxt.GOARCH before
-                // calling ctxt.ScanDir.
-                ctxt := build.Default
-                ctxt.IsAbsPath = pathpkg.IsAbs
-                ctxt.ReadDir = fsReadDir
-                ctxt.OpenFile = fsOpenFile
-                dir, err := ctxt.ImportDir(abspath, 0)
-                if err == nil {
-                        pkgFiles = append(dir.GoFiles, dir.CgoFiles...)
-                }
+        // Note: Uses current binary's GOOS/GOARCH.
+        // To use different pair, such as if we allowed the user
+        // to choose, set ctxt.GOOS and ctxt.GOARCH before
+        // calling ctxt.ScanDir.
+        ctxt := build.Default
+        ctxt.IsAbsPath = pathpkg.IsAbs
+        ctxt.ReadDir = fsReadDir
+        ctxt.OpenFile = fsOpenFile
+        if dir, err := ctxt.ImportDir(abspath, 0); err == nil {
+                pkgFiles = append(dir.GoFiles, dir.CgoFiles...)
         }
 
         // filter function to select the desired .go files
         filter := func(d os.FileInfo) bool {
                 // Only Go files.
                 if !isPkgFile(d) {
                         return false
                 }
                 // If we are looking at cmd documentation, only accept
                 // the special fakePkgFile containing the documentation.
                 if !h.isPkg {
                         return d.Name() == fakePkgFile
                 }
                 // Also restrict file list to pkgFiles.
                 return pkgFiles == nil || inList(d.Name(), pkgFiles)
         }
 
         // get package ASTs
         fset := token.NewFileSet()
         pkgs, err := parseDir(fset, abspath, filter)
-        if err != nil && pkgs == nil {
-                // only report directory read errors, ignore parse errors
-                // (may be able to extract partial package information)
+        if err != nil {
                 return PageInfo{Dirname: abspath, Err: err}
         }
 
         // select package
         var pkg *ast.Package // selected package
-        var plist []string   // list of other package (names), if any
         if len(pkgs) == 1 {
                 // Exactly one package - select it.
                 for _, p := range pkgs {
                         pkg = p
                 }
 
         } else if len(pkgs) > 1 {
-                // Multiple packages - select the best matching package: The
-                // 1st choice is the package with pkgname, the 2nd choice is
-                // the package with dirname, and the 3rd choice is a package
-                // that is not called "main" if there is exactly one such
-                // package. Otherwise, don't select a package.
-                dirpath, dirname := pathpkg.Split(abspath)
-
-                // If the dirname is "go" we might be in a sub-directory for
-                // .go files - use the outer directory name instead for better
-                // results.
-                if dirname == "go" {
-                        _, dirname = pathpkg.Split(pathpkg.Clean(dirpath))
+                // More than one package - report an error.
+                var buf bytes.Buffer
+                for _, p := range pkgs {
+                        if buf.Len() > 0 {
+                                fmt.Fprintf(&buf, ", ")
+                        }
+                        fmt.Fprintf(&buf, p.Name)
                 }
-
-                var choice3 *ast.Package
-        loop:
-                for _, p := range pkgs {
-                        switch {
-                        case p.Name == pkgname:
-                                pkg = p
-                                break loop // 1st choice; we are done
-                        case p.Name == dirname:
-                                pkg = p // 2nd choice
-                        case p.Name != "main":
-                                choice3 = p
-                        }
+                return PageInfo{
+                        Dirname: abspath,
+                        Err:     fmt.Errorf("%s contains more than one package: %s", abspath, buf.Bytes()),
                 }
-                if pkg == nil && len(pkgs) == 2 {
-                        pkg = choice3
-                }
-
-                // Compute the list of other packages
-                // (excluding the selected package, if any).
-                plist = make([]string, len(pkgs))
-                i := 0
-                for name := range pkgs {
-                        if pkg == nil || name != pkg.Name {
-                                plist[i] = name
-                                i++
-                        }
-                }
-                plist = plist[0:i]
-                sort.Strings(plist)
         }
 
         // get examples from *_test.go files
         var examples []*doc.Example
         filter = func(d os.FileInfo) bool {
                 return isGoFile(d) && strings.HasSuffix(d.Name(), "_test.go")
         }
         if testpkgs, err := parseDir(fset, abspath, filter); err != nil {
                 log.Println("parsing test files:", err)
         } else {
@@ skipping 45 matching lines @@
                 // no directory tree present (too early after startup or
                 // command-line mode); compute one level for this page
                 // note: cannot use path filter here because in general
                 //       it doesn't contain the fsTree path
                 dir = newDirectory(abspath, 1)
                 timestamp = time.Now()
         }
 
         return PageInfo{
                 Dirname:  abspath,
-                PList:    plist,
                 FSet:     fset,
                 PAst:     past,
                 PDoc:     pdoc,
                 Examples: examples,
                 Dirs:     dir.listing(true),
                 DirTime:  timestamp,
                 DirFlat:  mode&flatDir != 0,
                 IsPkg:    h.isPkg,
                 Err:      nil,
         }
 }
 
 func (h *docServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
         if redirect(w, r) {
                 return
         }
 
         relpath := pathpkg.Clean(r.URL.Path[len(h.pattern):])
         abspath := pathpkg.Join(h.fsRoot, relpath)
         mode := getPageInfoMode(r)
         if relpath == builtinPkgPath {
                 mode = noFiltering
         }
-        info := h.getPageInfo(abspath, relpath, r.FormValue("p"), mode)
+        info := h.getPageInfo(abspath, relpath, mode)
         if info.Err != nil {
                 log.Print(info.Err)
                 serveError(w, r, relpath, info.Err)
                 return
         }
 
         if mode&noHtml != 0 {
                 serveText(w, applyTemplate(packageText, "packageText", info))
                 return
         }
@@ skipping 361 matching lines @@
                         updateIndex()
                 }
                 delay := 60 * time.Second // by default, try every 60s
                 if *testDir != "" {
                         // in test mode, try once a second for fast startup
                         delay = 1 * time.Second
                 }
                 time.Sleep(delay)
         }
 }