+++ /dev/null
-// Copyright 2013 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 (
- "bufio"
- "bytes"
- "errors"
- "flag"
- "fmt"
- "go/scanner"
- "io"
- "io/ioutil"
- "log"
- "os"
- "os/exec"
- "path/filepath"
- "runtime"
- "runtime/pprof"
- "strings"
-
- "golang.org/x/tools/internal/gocommand"
- "golang.org/x/tools/internal/imports"
-)
-
-var (
- // main operation modes
- list = flag.Bool("l", false, "list files whose formatting differs from goimport's")
- write = flag.Bool("w", false, "write result to (source) file instead of stdout")
- doDiff = flag.Bool("d", false, "display diffs instead of rewriting files")
- srcdir = flag.String("srcdir", "", "choose imports as if source code is from `dir`. When operating on a single file, dir may instead be the complete file name.")
-
- verbose bool // verbose logging
-
- cpuProfile = flag.String("cpuprofile", "", "CPU profile output")
- memProfile = flag.String("memprofile", "", "memory profile output")
- memProfileRate = flag.Int("memrate", 0, "if > 0, sets runtime.MemProfileRate")
-
- options = &imports.Options{
- TabWidth: 8,
- TabIndent: true,
- Comments: true,
- Fragment: true,
- Env: &imports.ProcessEnv{
- GocmdRunner: &gocommand.Runner{},
- },
- }
- exitCode = 0
-)
-
-func init() {
- flag.BoolVar(&options.AllErrors, "e", false, "report all errors (not just the first 10 on different lines)")
- flag.StringVar(&options.LocalPrefix, "local", "", "put imports beginning with this string after 3rd-party packages; comma-separated list")
- flag.BoolVar(&options.FormatOnly, "format-only", false, "if true, don't fix imports and only format. In this mode, goimports is effectively gofmt, with the addition that imports are grouped into sections.")
-}
-
-func report(err error) {
- scanner.PrintError(os.Stderr, err)
- exitCode = 2
-}
-
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: goimports [flags] [path ...]\n")
- flag.PrintDefaults()
- os.Exit(2)
-}
-
-func isGoFile(f os.FileInfo) bool {
- // ignore non-Go files
- name := f.Name()
- return !f.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go")
-}
-
-// argumentType is which mode goimports was invoked as.
-type argumentType int
-
-const (
- // fromStdin means the user is piping their source into goimports.
- fromStdin argumentType = iota
-
- // singleArg is the common case from editors, when goimports is run on
- // a single file.
- singleArg
-
- // multipleArg is when the user ran "goimports file1.go file2.go"
- // or ran goimports on a directory tree.
- multipleArg
-)
-
-func processFile(filename string, in io.Reader, out io.Writer, argType argumentType) error {
- opt := options
- if argType == fromStdin {
- nopt := *options
- nopt.Fragment = true
- opt = &nopt
- }
-
- if in == nil {
- f, err := os.Open(filename)
- if err != nil {
- return err
- }
- defer f.Close()
- in = f
- }
-
- src, err := ioutil.ReadAll(in)
- if err != nil {
- return err
- }
-
- target := filename
- if *srcdir != "" {
- // Determine whether the provided -srcdirc is a directory or file
- // and then use it to override the target.
- //
- // See https://github.com/dominikh/go-mode.el/issues/146
- if isFile(*srcdir) {
- if argType == multipleArg {
- return errors.New("-srcdir value can't be a file when passing multiple arguments or when walking directories")
- }
- target = *srcdir
- } else if argType == singleArg && strings.HasSuffix(*srcdir, ".go") && !isDir(*srcdir) {
- // For a file which doesn't exist on disk yet, but might shortly.
- // e.g. user in editor opens $DIR/newfile.go and newfile.go doesn't yet exist on disk.
- // The goimports on-save hook writes the buffer to a temp file
- // first and runs goimports before the actual save to newfile.go.
- // The editor's buffer is named "newfile.go" so that is passed to goimports as:
- // goimports -srcdir=/gopath/src/pkg/newfile.go /tmp/gofmtXXXXXXXX.go
- // and then the editor reloads the result from the tmp file and writes
- // it to newfile.go.
- target = *srcdir
- } else {
- // Pretend that file is from *srcdir in order to decide
- // visible imports correctly.
- target = filepath.Join(*srcdir, filepath.Base(filename))
- }
- }
-
- res, err := imports.Process(target, src, opt)
- if err != nil {
- return err
- }
-
- if !bytes.Equal(src, res) {
- // formatting has changed
- if *list {
- fmt.Fprintln(out, filename)
- }
- if *write {
- if argType == fromStdin {
- // filename is "<standard input>"
- return errors.New("can't use -w on stdin")
- }
- // On Windows, we need to re-set the permissions from the file. See golang/go#38225.
- var perms os.FileMode
- if fi, err := os.Stat(filename); err == nil {
- perms = fi.Mode() & os.ModePerm
- }
- err = ioutil.WriteFile(filename, res, perms)
- if err != nil {
- return err
- }
- }
- if *doDiff {
- if argType == fromStdin {
- filename = "stdin.go" // because <standard input>.orig looks silly
- }
- data, err := diff(src, res, filename)
- if err != nil {
- return fmt.Errorf("computing diff: %s", err)
- }
- fmt.Printf("diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
- out.Write(data)
- }
- }
-
- if !*list && !*write && !*doDiff {
- _, err = out.Write(res)
- }
-
- return err
-}
-
-func visitFile(path string, f os.FileInfo, err error) error {
- if err == nil && isGoFile(f) {
- err = processFile(path, nil, os.Stdout, multipleArg)
- }
- if err != nil {
- report(err)
- }
- return nil
-}
-
-func walkDir(path string) {
- filepath.Walk(path, visitFile)
-}
-
-func main() {
- runtime.GOMAXPROCS(runtime.NumCPU())
-
- // call gofmtMain in a separate function
- // so that it can use defer and have them
- // run before the exit.
- gofmtMain()
- os.Exit(exitCode)
-}
-
-// parseFlags parses command line flags and returns the paths to process.
-// It's a var so that custom implementations can replace it in other files.
-var parseFlags = func() []string {
- flag.BoolVar(&verbose, "v", false, "verbose logging")
-
- flag.Parse()
- return flag.Args()
-}
-
-func bufferedFileWriter(dest string) (w io.Writer, close func()) {
- f, err := os.Create(dest)
- if err != nil {
- log.Fatal(err)
- }
- bw := bufio.NewWriter(f)
- return bw, func() {
- if err := bw.Flush(); err != nil {
- log.Fatalf("error flushing %v: %v", dest, err)
- }
- if err := f.Close(); err != nil {
- log.Fatal(err)
- }
- }
-}
-
-func gofmtMain() {
- flag.Usage = usage
- paths := parseFlags()
-
- if *cpuProfile != "" {
- bw, flush := bufferedFileWriter(*cpuProfile)
- pprof.StartCPUProfile(bw)
- defer flush()
- defer pprof.StopCPUProfile()
- }
- // doTrace is a conditionally compiled wrapper around runtime/trace. It is
- // used to allow goimports to compile under gccgo, which does not support
- // runtime/trace. See https://golang.org/issue/15544.
- defer doTrace()()
- if *memProfileRate > 0 {
- runtime.MemProfileRate = *memProfileRate
- bw, flush := bufferedFileWriter(*memProfile)
- defer func() {
- runtime.GC() // materialize all statistics
- if err := pprof.WriteHeapProfile(bw); err != nil {
- log.Fatal(err)
- }
- flush()
- }()
- }
-
- if verbose {
- log.SetFlags(log.LstdFlags | log.Lmicroseconds)
- options.Env.Logf = log.Printf
- }
- if options.TabWidth < 0 {
- fmt.Fprintf(os.Stderr, "negative tabwidth %d\n", options.TabWidth)
- exitCode = 2
- return
- }
-
- if len(paths) == 0 {
- if err := processFile("<standard input>", os.Stdin, os.Stdout, fromStdin); err != nil {
- report(err)
- }
- return
- }
-
- argType := singleArg
- if len(paths) > 1 {
- argType = multipleArg
- }
-
- for _, path := range paths {
- switch dir, err := os.Stat(path); {
- case err != nil:
- report(err)
- case dir.IsDir():
- walkDir(path)
- default:
- if err := processFile(path, nil, os.Stdout, argType); err != nil {
- report(err)
- }
- }
- }
-}
-
-func writeTempFile(dir, prefix string, data []byte) (string, error) {
- file, err := ioutil.TempFile(dir, prefix)
- if err != nil {
- return "", err
- }
- _, err = file.Write(data)
- if err1 := file.Close(); err == nil {
- err = err1
- }
- if err != nil {
- os.Remove(file.Name())
- return "", err
- }
- return file.Name(), nil
-}
-
-func diff(b1, b2 []byte, filename string) (data []byte, err error) {
- f1, err := writeTempFile("", "gofmt", b1)
- if err != nil {
- return
- }
- defer os.Remove(f1)
-
- f2, err := writeTempFile("", "gofmt", b2)
- if err != nil {
- return
- }
- defer os.Remove(f2)
-
- cmd := "diff"
- if runtime.GOOS == "plan9" {
- cmd = "/bin/ape/diff"
- }
-
- data, err = exec.Command(cmd, "-u", f1, f2).CombinedOutput()
- if len(data) > 0 {
- // diff exits with a non-zero status when the files don't match.
- // Ignore that failure as long as we get output.
- return replaceTempFilename(data, filename)
- }
- return
-}
-
-// replaceTempFilename replaces temporary filenames in diff with actual one.
-//
-// --- /tmp/gofmt316145376 2017-02-03 19:13:00.280468375 -0500
-// +++ /tmp/gofmt617882815 2017-02-03 19:13:00.280468375 -0500
-// ...
-// ->
-// --- path/to/file.go.orig 2017-02-03 19:13:00.280468375 -0500
-// +++ path/to/file.go 2017-02-03 19:13:00.280468375 -0500
-// ...
-func replaceTempFilename(diff []byte, filename string) ([]byte, error) {
- bs := bytes.SplitN(diff, []byte{'\n'}, 3)
- if len(bs) < 3 {
- return nil, fmt.Errorf("got unexpected diff for %s", filename)
- }
- // Preserve timestamps.
- var t0, t1 []byte
- if i := bytes.LastIndexByte(bs[0], '\t'); i != -1 {
- t0 = bs[0][i:]
- }
- if i := bytes.LastIndexByte(bs[1], '\t'); i != -1 {
- t1 = bs[1][i:]
- }
- // Always print filepath with slash separator.
- f := filepath.ToSlash(filename)
- bs[0] = []byte(fmt.Sprintf("--- %s%s", f+".orig", t0))
- bs[1] = []byte(fmt.Sprintf("+++ %s%s", f, t1))
- return bytes.Join(bs, []byte{'\n'}), nil
-}
-
-// isFile reports whether name is a file.
-func isFile(name string) bool {
- fi, err := os.Stat(name)
- return err == nil && fi.Mode().IsRegular()
-}
-
-// isDir reports whether name is a directory.
-func isDir(name string) bool {
- fi, err := os.Stat(name)
- return err == nil && fi.IsDir()
-}
projects / dotfiles / .git / blobdiff