diff --git a/cmd/puffsfmt/main.go b/cmd/puffsfmt/main.go new file mode 100644 index 00000000..b182c788 --- /dev/null +++ b/cmd/puffsfmt/main.go @@ -0,0 +1,162 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +package main + +import ( + "bytes" + "errors" + "flag" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "runtime" + "strings" + + "github.com/google/puffs/lang/parse" + "github.com/google/puffs/lang/render" + "github.com/google/puffs/lang/token" +) + +var ( + lFlag = flag.Bool("l", false, "list files whose formatting differs from puffsfmt's") + wFlag = flag.Bool("w", false, "write result to (source) file instead of stdout") +) + +func usage() { + fmt.Fprintf(os.Stderr, "usage: puffsfmt [flags] [path ...]\n") + flag.PrintDefaults() +} + +func main() { + if err := main1(); err != nil { + fmt.Fprintln(os.Stderr, err.Error()) + os.Exit(1) + } +} + +func main1() error { + flag.Usage = usage + flag.Parse() + + if flag.NArg() == 0 { + if *lFlag { + return errors.New("cannot use -l with standard input") + } + if *wFlag { + return errors.New("cannot use -w with standard input") + } + return do(os.Stdin, "") + } + + if !*lFlag && !*wFlag { + return errors.New("must use -l or -w if paths are given") + } + + for i := 0; i < flag.NArg(); i++ { + arg := flag.Arg(i) + switch dir, err := os.Stat(arg); { + case err != nil: + return err + case dir.IsDir(): + return filepath.Walk(arg, walk) + default: + if err := do(nil, arg); err != nil { + return err + } + } + } + + return nil +} + +func isPuffsFile(info os.FileInfo) bool { + name := info.Name() + return !info.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".puffs") +} + +func walk(filename string, info os.FileInfo, err error) error { + if err == nil && isPuffsFile(info) { + err = do(nil, filename) + } + // Don't complain if a file was deleted in the meantime (i.e. the directory + // changed concurrently while running puffsfmt). + if err != nil && !os.IsNotExist(err) { + return err + } + return nil +} + +func do(r io.Reader, filename string) error { + src, err := []byte(nil), error(nil) + if r != nil { + src, err = ioutil.ReadAll(r) + } else { + src, err = ioutil.ReadFile(filename) + } + if err != nil { + return err + } + + idMap := token.IDMap{} + tokens, comments, err := token.Tokenize(src, &idMap, filename) + if err != nil { + return err + } + // We don't need the AST node to pretty-print, but it's worth puffsfmt + // rejecting syntax errors. This is just a parse, not a full type check. + if _, err := parse.ParseFile(tokens, &idMap, filename); err != nil { + return err + } + buf := &bytes.Buffer{} + if err := render.RenderFile(buf, tokens, comments, &idMap); err != nil { + return err + } + dst := buf.Bytes() + + if r != nil { + if _, err := os.Stdout.Write(dst); err != nil { + return err + } + } else if !bytes.Equal(dst, src) { + if *lFlag { + fmt.Println(filename) + } + if *wFlag { + if err := writeFile(filename, dst); err != nil { + return err + } + } + } + + return nil +} + +const chmodSupported = runtime.GOOS != "windows" + +func writeFile(filename string, b []byte) error { + info, err := os.Stat(filename) + if err != nil { + return err + } + f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename)) + if err != nil { + return err + } + if chmodSupported { + f.Chmod(info.Mode().Perm()) + } + _, werr := f.Write(b) + cerr := f.Close() + if werr != nil { + os.Remove(f.Name()) + return werr + } + if cerr != nil { + os.Remove(f.Name()) + return cerr + } + return os.Rename(f.Name(), filename) +}