зеркало из https://github.com/github/depstubber.git
147 строки
3.1 KiB
Go
147 строки
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"runtime/debug"
|
|
"strings"
|
|
|
|
"golang.org/x/tools/go/packages"
|
|
)
|
|
|
|
// removeDot removes a dot from the end of `s`, if it ends with a dot.
|
|
func removeDot(s string) string {
|
|
if len(s) > 0 && s[len(s)-1] == '.' {
|
|
return s[0 : len(s)-1]
|
|
}
|
|
return s
|
|
}
|
|
|
|
// packageNameOfDir get package import path via dir
|
|
func packageNameOfDir(srcDir string) (string, error) {
|
|
files, err := ioutil.ReadDir(srcDir)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
var goFilePath string
|
|
for _, file := range files {
|
|
if !file.IsDir() && strings.HasSuffix(file.Name(), ".go") {
|
|
goFilePath = file.Name()
|
|
break
|
|
}
|
|
}
|
|
if goFilePath == "" {
|
|
return "", fmt.Errorf("go source file not found %s", srcDir)
|
|
}
|
|
|
|
packageImport, err := parsePackageImport(goFilePath, srcDir)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return packageImport, nil
|
|
}
|
|
|
|
func printModuleVersion() {
|
|
if bi, exists := debug.ReadBuildInfo(); exists {
|
|
fmt.Println(bi.Main.Version)
|
|
} else {
|
|
log.Printf("No version information found. Make sure to use " +
|
|
"GO111MODULE=on when running 'go get' in order to use specific " +
|
|
"version of the binary.")
|
|
}
|
|
}
|
|
|
|
// parseImportPackage get package import path via source file
|
|
func parsePackageImport(source, srcDir string) (string, error) {
|
|
cfg := &packages.Config{
|
|
Mode: packages.NeedName,
|
|
Tests: true,
|
|
Dir: srcDir,
|
|
}
|
|
pkgs, err := packages.Load(cfg, "file="+source)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if packages.PrintErrors(pkgs) > 0 || len(pkgs) == 0 {
|
|
return "", errors.New("loading package failed")
|
|
}
|
|
|
|
packageImport := pkgs[0].PkgPath
|
|
|
|
// It is illegal to import a _test package.
|
|
packageImport = strings.TrimSuffix(packageImport, "_test")
|
|
return packageImport, nil
|
|
}
|
|
|
|
func split(s string) []string {
|
|
return strings.FieldsFunc(s, func(c rune) bool { return c == ',' })
|
|
}
|
|
|
|
func DirExists(path string) (bool, error) {
|
|
return FileExists(path)
|
|
}
|
|
|
|
func FileExists(filepath string) (bool, error) {
|
|
_, err := os.Stat(filepath)
|
|
if os.IsNotExist(err) {
|
|
return false, nil
|
|
}
|
|
if err == nil {
|
|
return true, nil
|
|
}
|
|
return false, err
|
|
}
|
|
|
|
// CreateFolderIfNotExists creates a folder if it does not exists.
|
|
func CreateFolderIfNotExists(name string, perm os.FileMode) error {
|
|
_, err := os.Stat(name)
|
|
if os.IsNotExist(err) {
|
|
return os.MkdirAll(name, perm)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func MustCreateFolderIfNotExists(path string, perm os.FileMode) {
|
|
err := CreateFolderIfNotExists(path, perm)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("error creating dir %q: %s", path, err))
|
|
}
|
|
}
|
|
|
|
func MustCopyFile(src, dst string) {
|
|
_, err := copyFile(src, dst)
|
|
if err != nil {
|
|
log.Fatalf("error copying %q to %q: %s", src, dst, err)
|
|
}
|
|
}
|
|
|
|
func copyFile(src, dst string) (int64, error) {
|
|
sourceFileStat, err := os.Stat(src)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if !sourceFileStat.Mode().IsRegular() {
|
|
return 0, fmt.Errorf("%s is not a regular file", src)
|
|
}
|
|
|
|
source, err := os.Open(src)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer source.Close()
|
|
|
|
destination, err := os.Create(dst)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer destination.Close()
|
|
nBytes, err := io.Copy(destination, source)
|
|
return nBytes, err
|
|
}
|