Implement 'new' command for clients and servers

Author: juho05

go.sum

@@ -4,8 +4,6 @@ github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63n
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
 github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls=
 github.com/adrg/xdg v0.4.0/go.mod h1:N6ag73EX4wyxeaoeHctc1mas01KZgsj5tYiAIwqJE/E=
-github.com/code-game-project/codegame-cli v0.4.1 h1:FCZtp/coj+oHdJFvfD6rbtFqttma6GvkORgbhLfTl3A=
-github.com/code-game-project/codegame-cli v0.4.1/go.mod h1:oKjILTs/tR+V8adC7hben2t4zXRW+3kzdI1KbTASkBc=
 github.com/code-game-project/codegame-cli v0.4.2 h1:2h+X0tqMmIOCr3fnGYeLeTxRP9K8ie3XzNAEGl6JRB4=
 github.com/code-game-project/codegame-cli v0.4.2/go.mod h1:oKjILTs/tR+V8adC7hben2t4zXRW+3kzdI1KbTASkBc=
 github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=

main.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/code-game-project/codegame-cli-go/new/client"
+	"github.com/code-game-project/codegame-cli-go/new/server"
+	"github.com/spf13/pflag"
+)
+
+func main() {
+	var gameName string
+	pflag.StringVar(&gameName, "game-name", "", "The name of the game. (required for clients)")
+
+	var url string
+	pflag.StringVar(&url, "url", "", "The URL of the game. (required for clients)")
+
+	var cgVersion string
+	pflag.StringVar(&cgVersion, "cg-version", "", "The CodeGame protocol version of the game, e.g. 0.6 (required for clients)")
+
+	var cgeVersion string
+	pflag.StringVar(&cgeVersion, "cge-version", "", "The CGE version of the game, e.g. 0.3 (required for clients)")
+
+	pflag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: %s <command> [...]\n", os.Args[0])
+		fmt.Fprintln(os.Stderr, "\nCommands:")
+		fmt.Fprintln(os.Stderr, "\tnew \tCreate a new project.")
+		fmt.Fprintln(os.Stderr, "\nOptions:")
+		pflag.PrintDefaults()
+	}
+
+	pflag.Parse()
+	if pflag.NArg() < 2 {
+		pflag.Usage()
+		os.Exit(1)
+	}
+
+	workingDir, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+	}
+	projectName := filepath.Base(workingDir)
+
+	command := strings.ToLower(pflag.Arg(0))
+
+	switch command {
+	case "new":
+		err = new(projectName, gameName, url, cgVersion, cgeVersion)
+	default:
+		err = fmt.Errorf("Unknown command: %s\n", command)
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func new(projectName, gameName, url, cgVersion, cgeVersion string) error {
+	projectType := strings.ToLower(pflag.Arg(1))
+
+	var err error
+	switch projectType {
+	case "client":
+		err = client.CreateNewClient(projectName, gameName, url, cgVersion, cgeVersion)
+	case "server":
+		err = server.CreateNewServer(projectName)
+	default:
+		err = fmt.Errorf("Unknown project type: %s\n", projectType)
+	}
+
+	return err
+}

new/client/client.go

@@ -0,0 +1,202 @@
+package client
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	_ "embed"
+
+	"github.com/code-game-project/codegame-cli-go/util"
+	"github.com/code-game-project/codegame-cli/cli"
+	"github.com/code-game-project/codegame-cli/external"
+)
+
+//go:embed templates/main.go.tmpl
+var goClientMainTemplate string
+
+//go:embed templates/wrappers/main.go.tmpl
+var goClientWrapperMainTemplate string
+
+//go:embed templates/wrappers/game.go.tmpl
+var goClientWrapperGameTemplate string
+
+//go:embed templates/wrappers/events.go.tmpl
+var goClientWrapperEventsTemplate string
+
+func CreateNewClient(projectName, gameName, serverURL, cgVersion, cgeVersion string) error {
+	module, err := cli.Input("Project module path:")
+	if err != nil {
+		return err
+	}
+
+	out, err := external.ExecuteHidden("go", "mod", "init", module)
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+
+	libraryURL, libraryTag, err := getGoClientLibraryURL(projectName, cgVersion)
+	if err != nil {
+		return err
+	}
+
+	cgeMajor, cgeMinor, _, err := external.ParseVersion(cgeVersion)
+	if err != nil {
+		return cli.Error(err.Error())
+	}
+
+	wrappers := false
+	if cgeMajor > 0 || cgeMinor >= 3 {
+		wrappers, err = cli.YesNo("Do you want to generate helper functions?", true)
+		if err != nil {
+			return err
+		}
+	}
+
+	cli.Begin("Installing correct go-client version...")
+	out, err = external.ExecuteHidden("go", "get", fmt.Sprintf("%s@%s", libraryURL, libraryTag))
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+	cli.Finish()
+
+	cli.Begin("Creating project template...")
+	err = createGoClientTemplate(libraryTag, projectName, module, gameName, serverURL, libraryURL, cgeVersion, wrappers)
+	if err != nil {
+		return err
+	}
+	cli.Finish()
+
+	cli.Begin("Installing dependencies...")
+
+	out, err = external.ExecuteHidden("go", "mod", "tidy")
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+
+	cli.Finish()
+
+	cli.Begin("Organizing imports...")
+
+	if !external.IsInstalled("goimports") {
+		cli.Warn("Failed to organize import statements: 'goimports' is not installed!")
+		return nil
+	}
+	external.ExecuteHidden("goimports", "-w", "main.go")
+
+	cli.Finish()
+
+	return nil
+}
+
+func createGoClientTemplate(libraryTag, projectName, modulePath, gameName, serverURL, libraryURL, cgeVersion string, wrappers bool) error {
+	if !wrappers {
+		return execGoClientMainTemplate(projectName, serverURL, libraryURL)
+	}
+
+	return execGoClientWrappersTemplate(projectName, modulePath, gameName, serverURL, libraryURL, cgeVersion)
+}
+
+func getGoClientLibraryURL(projectName, cgVersion string) (url string, tag string, err error) {
+	clientVersion := external.ClientVersionFromCGVersion("code-game-project", "go-client", cgVersion)
+
+	if clientVersion == "latest" {
+		var err error
+		clientVersion, err = external.LatestGithubTag("code-game-project", "go-client")
+		if err != nil {
+			return "", "", err
+		}
+		clientVersion = strings.TrimPrefix(strings.Join(strings.Split(clientVersion, ".")[:2], "."), "v")
+	}
+
+	majorVersion := strings.Split(clientVersion, ".")[0]
+	tag, err = external.GithubTagFromVersion("code-game-project", "go-client", clientVersion)
+	if err != nil {
+		return "", "", err
+	}
+	path := "github.com/code-game-project/go-client/cg"
+	if majorVersion != "0" && majorVersion != "1" {
+		path = fmt.Sprintf("github.com/code-game-project/go-client/v%s/cg", majorVersion)
+	}
+
+	return path, tag, nil
+}
+
+func execGoClientMainTemplate(projectName, serverURL, libraryURL string) error {
+	type data struct {
+		URL        string
+		LibraryURL string
+	}
+
+	return util.ExecTemplate(goClientMainTemplate, "main.go", data{
+		URL:        serverURL,
+		LibraryURL: libraryURL,
+	})
+}
+
+func execGoClientWrappersTemplate(projectName, modulePath, gameName, serverURL, libraryURL, cgeVersion string) error {
+	gamePackageName := strings.ReplaceAll(strings.ReplaceAll(gameName, "-", ""), "_", "")
+
+	gameDir := strings.ReplaceAll(strings.ReplaceAll(gameName, "-", ""), "_", "")
+
+	eventNames, err := external.GetEventNames(util.BaseURL(serverURL, util.IsSSL(serverURL)), cgeVersion)
+	if err != nil {
+		return err
+	}
+
+	type event struct {
+		Name       string
+		PascalName string
+	}
+
+	events := make([]event, len(eventNames))
+	for i, e := range eventNames {
+		pascal := strings.ReplaceAll(e, "_", " ")
+		pascal = strings.Title(pascal)
+		pascal = strings.ReplaceAll(pascal, " ", "")
+		events[i] = event{
+			Name:       e,
+			PascalName: pascal,
+		}
+	}
+
+	data := struct {
+		URL         string
+		LibraryURL  string
+		PackageName string
+		ModulePath  string
+		Events      []event
+	}{
+		URL:         serverURL,
+		LibraryURL:  libraryURL,
+		PackageName: gamePackageName,
+		ModulePath:  modulePath,
+		Events:      events,
+	}
+
+	err = util.ExecTemplate(goClientWrapperMainTemplate, filepath.Join("main.go"), data)
+	if err != nil {
+		return err
+	}
+
+	err = util.ExecTemplate(goClientWrapperGameTemplate, filepath.Join(gameDir, "game.go"), data)
+	if err != nil {
+		return err
+	}
+
+	err = util.ExecTemplate(goClientWrapperEventsTemplate, filepath.Join(gameDir, "events.go"), data)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

new/client/templates/main.go.tmpl

@@ -0,0 +1,10 @@
+package main
+
+import "{{.LibraryURL}}"
+
+func main() {
+	socket, err := cg.NewSocket("{{.URL}}")
+	if err != nil {
+		log.Fatalf("failed to connect to server: %s", err)
+	}
+}

new/client/templates/wrappers/events.go.tmpl

@@ -0,0 +1,51 @@
+package {{.PackageName}}
+
+import "{{.LibraryURL}}"
+
+{{range .Events}}
+// On{{.PascalName}}Event triggers the callback every time the `{{.Name}}` event is received.
+func (g *Game) On{{.PascalName}}Event(callback func(origin Player, data {{.PascalName}}EventData)) cg.CallbackId {
+	return g.socket.On({{.PascalName}}Event, func(origin string, event cg.Event) {
+		var data {{.PascalName}}EventData
+		err := event.UnmarshalData(&data)
+		if err == nil {
+			username := g.socket.ResolveUsername(origin)
+			if origin == "server" {
+				username = "Server"
+			}
+			callback(Player{
+				Id:       origin,
+				Username: username,
+			}, data)
+		}
+	})
+}
+
+// On{{.PascalName}}EventOnce triggers the callback the next time the `{{.Name}}` event is received.
+func (g *Game) On{{.PascalName}}EventOnce(callback func(origin Player, data {{.PascalName}}EventData)) cg.CallbackId {
+	return g.socket.Once({{.PascalName}}Event, func(origin string, event cg.Event) {
+		var data {{.PascalName}}EventData
+		err := event.UnmarshalData(&data)
+		if err == nil {
+			username := g.socket.ResolveUsername(origin)
+			if origin == "server" {
+				username = "Server"
+			}
+			callback(Player{
+				Id:       origin,
+				Username: username,
+			}, data)
+		}
+	})
+}
+
+// Send{{.PascalName}}Event sends a `{{.Name}}` event.
+func (g *Game) Send{{.PascalName}}Event(data {{.PascalName}}EventData) error {
+	return g.socket.Send({{.PascalName}}Event, data)
+}
+{{end}}
+
+// RemoveCallback removes the callback with the specified id.
+func (g *Game) RemoveCallback(id cg.CallbackId) {
+	g.socket.RemoveCallback(id)
+}