// fwwc is a an example program that recursively walks directories and // prints the number of lines in each file it encounters. package main import ( "bytes" "flag" "fmt" "io" "io/fs" "os" "path/filepath" "github.com/charlievieth/fastwalk" ) var newLine = []byte{'\n'} // countLinesInFile returns the number of newlines ('\n') in file name. func countLinesInFile(name string) (int64, error) { f, err := os.Open(name) if err != nil { return 0, err } defer f.Close() buf := make([]byte, 16*1024) var lines int64 for { n, e := f.Read(buf) if n > 0 { lines += int64(bytes.Count(buf[:n], newLine)) } if e != nil { if e != io.EOF { err = e } break } } return lines, err } func LineCount(root string, followLinks bool) error { countLinesWalkFn := func(path string, d fs.DirEntry, err error) error { // We wrap this with fastwalk.IgnorePermissionErrors so we know the // error is not a permission error (common when walking outside a users // home directory) and is likely something worse so we should return it // and abort the walk. // // A common error here is "too many open files", which can occur if the // walkFn opens, but does not close, files. if err != nil { return err } // If the entry is a symbolic link get the type of file that // it references. typ := d.Type() if typ&fs.ModeSymlink != 0 { if fi, err := fastwalk.StatDirEntry(path, d); err == nil { typ = fi.Mode().Type() } } // Skip dot (".") files (but allow "." / PWD as the path) if path != "." && typ.IsDir() { name := d.Name() if name == "" || name[0] == '.' || name[0] == '_' { return fastwalk.SkipDir } return nil } if typ.IsRegular() { lines, err := countLinesInFile(path) if err == nil { fmt.Printf("%8d %s\n", lines, path) } else { // Print but do not return the error. fmt.Fprintf(os.Stderr, "%s: %s\n", path, err) } } return nil } // Ignore permission errors traversing directories. // // Note: this only ignores permission errors when traversing directories. // Permission errors may still be encountered when accessing files. walkFn := fastwalk.IgnorePermissionErrors(countLinesWalkFn) conf := fastwalk.Config{ // Safely follow symbolic links. This can also be achieved by // wrapping walkFn with fastwalk.FollowSymlinks(). Follow: followLinks, // If NumWorkers is ≤ 0 the default is used, which is sufficient // for most use cases. } // Note: Walk can also be called with a nil Config, in which case // fastwalk.DefaultConfig is used. if err := fastwalk.Walk(&conf, root, walkFn); err != nil { return fmt.Errorf("walking directory %s: %w", root, err) } return nil } const UsageMsg = `Usage: %[1]s [-L] [PATH...]: %[1]s prints the number of lines in each file it finds, ignoring directories that start with '.' or '_'. ` func main() { flag.Usage = func() { fmt.Fprintf(os.Stdout, UsageMsg, filepath.Base(os.Args[0])) flag.PrintDefaults() } followLinks := flag.Bool("L", false, "Follow symbolic links") flag.Parse() args := flag.Args() if len(args) == 0 { args = append(args, ".") } for _, root := range args { // fmt.Println("ROOT:", root) if err := LineCount(root, *followLinks); err != nil { fmt.Fprintln(os.Stderr, "error:", err) os.Exit(1) } } }