code review 5699072: godoc: don't show directories w/o packages in flat dir mode

src/cmd/godoc/dirtrees.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.
 
 // This file contains the code dealing with package directory trees.
 
 package main
 
 import (
         "bytes"
         "go/doc"
         "go/parser"
         "go/token"
         "log"
         "os"
         "path/filepath"
         "strings"
 )
 
 // Conventional name for directories containing test data.
 // Excluded from directory trees.
 //
 const testdataDirName = "testdata"
 
 type Directory struct {
         Depth    int
         Path     string       // directory path; includes Name
         Name     string       // directory name
         HasPkg   bool         // true if the directory contains at least one package

[bradfitz, 2012/02/26 08:22:53]

package or command? or just package?

if the former (which I think it is?), I'd name this HasGoCode or HasCode maybe.

[Sameer Ajmani, 2012/02/27 01:44:15]

I'd color it HasFiles.

[gri, 2012/02/27 18:49:40]

As the comments says: at least one package. And a command is a package.

[gri, 2012/02/27 18:49:40]

HasFiles is misleading. This is about .go files who build a package, only.

         Synopsis string       // package documentation, if any
         Dirs     []*Directory // subdirectories
 }
 
 func isGoFile(fi os.FileInfo) bool {
         name := fi.Name()
         return !fi.IsDir() &&
                 len(name) > 0 && name[0] != '.' && // ignore .files
                 filepath.Ext(name) == ".go"
 }
@@ skipping 16 matching lines @@
 
 func (b *treeBuilder) newDirTree(fset *token.FileSet, path, name string, depth int) *Directory {
         if b.pathFilter != nil && !b.pathFilter(path) || name == testdataDirName {
                 return nil
         }
 
         if depth >= b.maxDepth {
                 // return a dummy directory so that the parent directory
                 // doesn't get discarded just because we reached the max
                 // directory depth
-                return &Directory{depth, path, name, false, "", nil}

[bradfitz, 2012/02/26 08:22:53]

I think this passed the reasonable limit for tagless composite literals a few
zero values ago.

[Sameer Ajmani, 2012/02/27 01:44:15]

+1

[gri, 2012/02/27 18:49:40]

Done.

[gri, 2012/02/27 18:49:40]

Done.

+                return &Directory{
+                        Depth: depth,
+                        Path:  path,
+                        Name:  name,
+                }
         }
 
         list, err := fs.ReadDir(path)
         if err != nil {
                 // newDirTree is called with a path that should be a package
                 // directory; errors here should not happen, but if they do,
                 // we want to know about them
                 log.Printf("ReadDir(%s): %s", path, err)
         }
 
@@ skipping 62 matching lines @@
         }
 
         // select the highest-priority synopsis for the directory entry, if any
         synopsis := ""
         for _, synopsis = range synopses {
                 if synopsis != "" {
                         break
                 }
         }
 
-        return &Directory{depth, path, name, hasPkgFiles, synopsis, dirs}

[bradfitz, 2012/02/26 08:22:53]

I'd spell this out too.  Too many of these share the same type (string), making
me nervous that the compiler won't catch things if you decide to reorder the
struct declaration for clarity.

[gri, 2012/02/27 18:49:40]

Done.

+        return &Directory{
+                Depth:    depth,
+                Path:     path,
+                Name:     name,
+                HasPkg:   hasPkgFiles,
+                Synopsis: synopsis,
+                Dirs:     dirs,
+        }
 }
 
 // newDirectory creates a new package directory tree with at most maxDepth
 // levels, anchored at root. The result tree is pruned such that it only
 // contains directories that contain package files or that contain
 // subdirectories containing package files (transitively). If a non-nil
 // pathFilter is provided, directory paths additionally must be accepted
 // by the filter (i.e., pathFilter(path) must be true). If a value >= 0 is
 // provided for maxDepth, nodes at larger depths are pruned as well; they
 // are assumed to contain package files even if their contents are not known
@@ skipping 146 matching lines @@
                 }
                 p.Path = path
                 p.Name = d.Name
                 p.HasPkg = d.HasPkg
                 p.Synopsis = d.Synopsis
                 i++
         }
 
         return &DirList{maxHeight, list}
 }