whatcanGOwrong
This commit is contained in:
@@ -0,0 +1,233 @@
|
||||
// Copyright 2023 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.
|
||||
|
||||
// Gonew starts a new Go module by copying a template module.
|
||||
//
|
||||
// Usage:
|
||||
//
|
||||
// gonew srcmod[@version] [dstmod [dir]]
|
||||
//
|
||||
// Gonew makes a copy of the srcmod module, changing its module path to dstmod.
|
||||
// It writes that new module to a new directory named by dir.
|
||||
// If dir already exists, it must be an empty directory.
|
||||
// If dir is omitted, gonew uses ./elem where elem is the final path element of dstmod.
|
||||
//
|
||||
// This command is highly experimental and subject to change.
|
||||
//
|
||||
// # Example
|
||||
//
|
||||
// To install gonew:
|
||||
//
|
||||
// go install golang.org/x/tools/cmd/gonew@latest
|
||||
//
|
||||
// To clone the basic command-line program template golang.org/x/example/hello
|
||||
// as your.domain/myprog, in the directory ./myprog:
|
||||
//
|
||||
// gonew golang.org/x/example/hello your.domain/myprog
|
||||
//
|
||||
// To clone the latest copy of the rsc.io/quote module, keeping that module path,
|
||||
// into ./quote:
|
||||
//
|
||||
// gonew rsc.io/quote
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"io/fs"
|
||||
"log"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/mod/modfile"
|
||||
"golang.org/x/mod/module"
|
||||
"golang.org/x/tools/internal/edit"
|
||||
)
|
||||
|
||||
func usage() {
|
||||
fmt.Fprintf(os.Stderr, "usage: gonew srcmod[@version] [dstmod [dir]]\n")
|
||||
fmt.Fprintf(os.Stderr, "See https://pkg.go.dev/golang.org/x/tools/cmd/gonew.\n")
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
func main() {
|
||||
log.SetPrefix("gonew: ")
|
||||
log.SetFlags(0)
|
||||
flag.Usage = usage
|
||||
flag.Parse()
|
||||
args := flag.Args()
|
||||
|
||||
if len(args) < 1 || len(args) > 3 {
|
||||
usage()
|
||||
}
|
||||
|
||||
srcMod := args[0]
|
||||
srcModVers := srcMod
|
||||
if !strings.Contains(srcModVers, "@") {
|
||||
srcModVers += "@latest"
|
||||
}
|
||||
srcMod, _, _ = strings.Cut(srcMod, "@")
|
||||
if err := module.CheckPath(srcMod); err != nil {
|
||||
log.Fatalf("invalid source module name: %v", err)
|
||||
}
|
||||
|
||||
dstMod := srcMod
|
||||
if len(args) >= 2 {
|
||||
dstMod = args[1]
|
||||
if err := module.CheckPath(dstMod); err != nil {
|
||||
log.Fatalf("invalid destination module name: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
var dir string
|
||||
if len(args) == 3 {
|
||||
dir = args[2]
|
||||
} else {
|
||||
dir = "." + string(filepath.Separator) + path.Base(dstMod)
|
||||
}
|
||||
|
||||
// Dir must not exist or must be an empty directory.
|
||||
de, err := os.ReadDir(dir)
|
||||
if err == nil && len(de) > 0 {
|
||||
log.Fatalf("target directory %s exists and is non-empty", dir)
|
||||
}
|
||||
needMkdir := err != nil
|
||||
|
||||
var stdout, stderr bytes.Buffer
|
||||
cmd := exec.Command("go", "mod", "download", "-json", srcModVers)
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
log.Fatalf("go mod download -json %s: %v\n%s%s", srcModVers, err, stderr.Bytes(), stdout.Bytes())
|
||||
}
|
||||
|
||||
var info struct {
|
||||
Dir string
|
||||
}
|
||||
if err := json.Unmarshal(stdout.Bytes(), &info); err != nil {
|
||||
log.Fatalf("go mod download -json %s: invalid JSON output: %v\n%s%s", srcMod, err, stderr.Bytes(), stdout.Bytes())
|
||||
}
|
||||
|
||||
if needMkdir {
|
||||
if err := os.MkdirAll(dir, 0777); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// Copy from module cache into new directory, making edits as needed.
|
||||
filepath.WalkDir(info.Dir, func(src string, d fs.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
rel, err := filepath.Rel(info.Dir, src)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
dst := filepath.Join(dir, rel)
|
||||
if d.IsDir() {
|
||||
if err := os.MkdirAll(dst, 0777); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
data, err := os.ReadFile(src)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
isRoot := !strings.Contains(rel, string(filepath.Separator))
|
||||
if strings.HasSuffix(rel, ".go") {
|
||||
data = fixGo(data, rel, srcMod, dstMod, isRoot)
|
||||
}
|
||||
if rel == "go.mod" {
|
||||
data = fixGoMod(data, srcMod, dstMod)
|
||||
}
|
||||
|
||||
if err := os.WriteFile(dst, data, 0666); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
|
||||
log.Printf("initialized %s in %s", dstMod, dir)
|
||||
}
|
||||
|
||||
// fixGo rewrites the Go source in data to replace srcMod with dstMod.
|
||||
// isRoot indicates whether the file is in the root directory of the module,
|
||||
// in which case we also update the package name.
|
||||
func fixGo(data []byte, file string, srcMod, dstMod string, isRoot bool) []byte {
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, file, data, parser.ImportsOnly)
|
||||
if err != nil {
|
||||
log.Fatalf("parsing source module:\n%s", err)
|
||||
}
|
||||
|
||||
buf := edit.NewBuffer(data)
|
||||
at := func(p token.Pos) int {
|
||||
return fset.File(p).Offset(p)
|
||||
}
|
||||
|
||||
srcName := path.Base(srcMod)
|
||||
dstName := path.Base(dstMod)
|
||||
if isRoot {
|
||||
if name := f.Name.Name; name == srcName || name == srcName+"_test" {
|
||||
dname := dstName + strings.TrimPrefix(name, srcName)
|
||||
if !token.IsIdentifier(dname) {
|
||||
log.Fatalf("%s: cannot rename package %s to package %s: invalid package name", file, name, dname)
|
||||
}
|
||||
buf.Replace(at(f.Name.Pos()), at(f.Name.End()), dname)
|
||||
}
|
||||
}
|
||||
|
||||
for _, spec := range f.Imports {
|
||||
path, err := strconv.Unquote(spec.Path.Value)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if path == srcMod {
|
||||
if srcName != dstName && spec.Name == nil {
|
||||
// Add package rename because source code uses original name.
|
||||
// The renaming looks strange, but template authors are unlikely to
|
||||
// create a template where the root package is imported by packages
|
||||
// in subdirectories, and the renaming at least keeps the code working.
|
||||
// A more sophisticated approach would be to rename the uses of
|
||||
// the package identifier in the file too, but then you have to worry about
|
||||
// name collisions, and given how unlikely this is, it doesn't seem worth
|
||||
// trying to clean up the file that way.
|
||||
buf.Insert(at(spec.Path.Pos()), srcName+" ")
|
||||
}
|
||||
// Change import path to dstMod
|
||||
buf.Replace(at(spec.Path.Pos()), at(spec.Path.End()), strconv.Quote(dstMod))
|
||||
}
|
||||
if strings.HasPrefix(path, srcMod+"/") {
|
||||
// Change import path to begin with dstMod
|
||||
buf.Replace(at(spec.Path.Pos()), at(spec.Path.End()), strconv.Quote(strings.Replace(path, srcMod, dstMod, 1)))
|
||||
}
|
||||
}
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
// fixGoMod rewrites the go.mod content in data to replace srcMod with dstMod
|
||||
// in the module path.
|
||||
func fixGoMod(data []byte, srcMod, dstMod string) []byte {
|
||||
f, err := modfile.ParseLax("go.mod", data, nil)
|
||||
if err != nil {
|
||||
log.Fatalf("parsing source module:\n%s", err)
|
||||
}
|
||||
f.AddModuleStmt(dstMod)
|
||||
new, err := f.Format()
|
||||
if err != nil {
|
||||
return data
|
||||
}
|
||||
return new
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
// Copyright 2023 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 (
|
||||
"archive/zip"
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/tools/internal/diffp"
|
||||
"golang.org/x/tools/internal/testenv"
|
||||
"golang.org/x/tools/txtar"
|
||||
)
|
||||
|
||||
func init() {
|
||||
if os.Getenv("TestGonewMain") == "1" {
|
||||
main()
|
||||
os.Exit(0)
|
||||
}
|
||||
}
|
||||
|
||||
func Test(t *testing.T) {
|
||||
if !testenv.HasExec() {
|
||||
t.Skipf("skipping test: exec not supported on %s/%s", runtime.GOOS, runtime.GOARCH)
|
||||
}
|
||||
exe, err := os.Executable()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Each file in testdata is a txtar file with the command to run,
|
||||
// the contents of modules to initialize in a fake proxy,
|
||||
// the expected stdout and stderr, and the expected file contents.
|
||||
files, err := filepath.Glob("testdata/*.txt")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(files) == 0 {
|
||||
t.Fatal("no test cases")
|
||||
}
|
||||
|
||||
for _, file := range files {
|
||||
t.Run(filepath.Base(file), func(t *testing.T) {
|
||||
data, err := os.ReadFile(file)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ar := txtar.Parse(data)
|
||||
|
||||
// If the command begins with ! it means it should fail.
|
||||
// After the optional ! the first argument must be 'gonew'
|
||||
// followed by the arguments to gonew.
|
||||
args := strings.Fields(string(ar.Comment))
|
||||
wantFail := false
|
||||
if len(args) > 0 && args[0] == "!" {
|
||||
wantFail = true
|
||||
args = args[1:]
|
||||
}
|
||||
if len(args) == 0 || args[0] != "gonew" {
|
||||
t.Fatalf("invalid command comment")
|
||||
}
|
||||
|
||||
// Collect modules into proxy tree and store in temp directory.
|
||||
dir := t.TempDir()
|
||||
proxyDir := filepath.Join(dir, "proxy")
|
||||
writeProxyFiles(t, proxyDir, ar)
|
||||
extra := ""
|
||||
if runtime.GOOS == "windows" {
|
||||
// Windows absolute paths don't start with / so we need one more.
|
||||
extra = "/"
|
||||
}
|
||||
proxyURL := "file://" + extra + filepath.ToSlash(proxyDir)
|
||||
|
||||
// Run gonew in a fresh 'out' directory.
|
||||
out := filepath.Join(dir, "out")
|
||||
if err := os.Mkdir(out, 0777); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cmd := exec.Command(exe, args[1:]...)
|
||||
cmd.Dir = out
|
||||
cmd.Env = append(os.Environ(), "TestGonewMain=1", "GOPROXY="+proxyURL, "GOSUMDB=off")
|
||||
var stdout bytes.Buffer
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err == nil && wantFail {
|
||||
t.Errorf("unexpected success exit")
|
||||
} else if err != nil && !wantFail {
|
||||
t.Errorf("unexpected failure exit")
|
||||
}
|
||||
|
||||
// Collect the expected output from the txtar.
|
||||
want := make(map[string]txtar.File)
|
||||
for _, f := range ar.Files {
|
||||
if f.Name == "stdout" || f.Name == "stderr" || strings.HasPrefix(f.Name, "out/") {
|
||||
want[f.Name] = f
|
||||
}
|
||||
}
|
||||
|
||||
// Check stdout and stderr.
|
||||
// Change \ to / so Windows output looks like Unix output.
|
||||
stdoutBuf := bytes.ReplaceAll(stdout.Bytes(), []byte(`\`), []byte("/"))
|
||||
stderrBuf := bytes.ReplaceAll(stderr.Bytes(), []byte(`\`), []byte("/"))
|
||||
// Note that stdout and stderr can be omitted from the archive if empty.
|
||||
if !bytes.Equal(stdoutBuf, want["stdout"].Data) {
|
||||
t.Errorf("wrong stdout: %s", diffp.Diff("want", want["stdout"].Data, "have", stdoutBuf))
|
||||
}
|
||||
if !bytes.Equal(stderrBuf, want["stderr"].Data) {
|
||||
t.Errorf("wrong stderr: %s", diffp.Diff("want", want["stderr"].Data, "have", stderrBuf))
|
||||
}
|
||||
delete(want, "stdout")
|
||||
delete(want, "stderr")
|
||||
|
||||
// Check remaining expected outputs.
|
||||
err = filepath.WalkDir(out, func(name string, info fs.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if info.IsDir() {
|
||||
return nil
|
||||
}
|
||||
data, err := os.ReadFile(name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
short := "out" + filepath.ToSlash(strings.TrimPrefix(name, out))
|
||||
f, ok := want[short]
|
||||
if !ok {
|
||||
t.Errorf("unexpected file %s:\n%s", short, data)
|
||||
return nil
|
||||
}
|
||||
delete(want, short)
|
||||
if !bytes.Equal(data, f.Data) {
|
||||
t.Errorf("wrong %s: %s", short, diffp.Diff("want", f.Data, "have", data))
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for name := range want {
|
||||
t.Errorf("missing file %s", name)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// A Zip is a zip file being written.
|
||||
type Zip struct {
|
||||
buf bytes.Buffer
|
||||
w *zip.Writer
|
||||
}
|
||||
|
||||
// writeProxyFiles collects all the module content from ar and writes
|
||||
// files in the format of the proxy URL space, so that the 'proxy' directory
|
||||
// can be used in a GOPROXY=file:/// URL.
|
||||
func writeProxyFiles(t *testing.T, proxy string, ar *txtar.Archive) {
|
||||
zips := make(map[string]*Zip)
|
||||
others := make(map[string]string)
|
||||
for _, f := range ar.Files {
|
||||
i := strings.Index(f.Name, "@")
|
||||
if i < 0 {
|
||||
continue
|
||||
}
|
||||
j := strings.Index(f.Name[i:], "/")
|
||||
if j < 0 {
|
||||
t.Fatalf("unexpected archive file %s", f.Name)
|
||||
}
|
||||
j += i
|
||||
mod, vers, file := f.Name[:i], f.Name[i+1:j], f.Name[j+1:]
|
||||
zipName := mod + "/@v/" + vers + ".zip"
|
||||
z := zips[zipName]
|
||||
if z == nil {
|
||||
others[mod+"/@v/list"] += vers + "\n"
|
||||
others[mod+"/@v/"+vers+".info"] = fmt.Sprintf("{%q: %q}\n", "Version", vers)
|
||||
z = new(Zip)
|
||||
z.w = zip.NewWriter(&z.buf)
|
||||
zips[zipName] = z
|
||||
}
|
||||
if file == "go.mod" {
|
||||
others[mod+"/@v/"+vers+".mod"] = string(f.Data)
|
||||
}
|
||||
w, err := z.w.Create(f.Name)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := w.Write(f.Data); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
for name, z := range zips {
|
||||
if err := z.w.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(filepath.Join(proxy, name)), 0777); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(proxy, name), z.buf.Bytes(), 0666); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
for name, data := range others {
|
||||
// zip loop already created directory
|
||||
if err := os.WriteFile(filepath.Join(proxy, name), []byte(data), 0666); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
gonew example.com/quote my.com/test
|
||||
|
||||
-- example.com/quote@v1.5.2/go.mod --
|
||||
module example.com/quote
|
||||
-- example.com/quote@v1.5.2/quote.go --
|
||||
package quote
|
||||
|
||||
import (
|
||||
"example.com/quote/bar"
|
||||
)
|
||||
|
||||
func Quote() {}
|
||||
-- example.com/quote@v1.5.2/quote/another.go --
|
||||
package quote // another package quote!
|
||||
-- stderr --
|
||||
gonew: initialized my.com/test in ./test
|
||||
-- out/test/go.mod --
|
||||
module my.com/test
|
||||
-- out/test/quote.go --
|
||||
package test
|
||||
|
||||
import (
|
||||
"my.com/test/bar"
|
||||
)
|
||||
|
||||
func Quote() {}
|
||||
-- out/test/quote/another.go --
|
||||
package quote // another package quote!
|
||||
Reference in New Issue
Block a user