webrpc-gen CLI v2 (webrpc-gen v0.6.1) (webrpc#110)

Author: VojtechVitek

.github/workflows/ci.yml

@@ -33,4 +33,4 @@ jobs:
       - name: Regenerate examples
         run: make generate
       - name: Git diff of regenerated examples
-        run: git diff --color --exit-code
+        run: git diff --color --ignore-all-space --ignore-blank-lines --exit-code

Makefile

@@ -37,7 +37,7 @@ generate:
 	@for i in _examples/*/Makefile; do           \
 		echo; echo $$ cd $$i \&\& make generate; \
 		cd $$(dirname $$i);                      \
-		make generate;                           \
+		make generate || exit 1;                 \
 		cd ../../;                               \
 	done
 

cmd/webrpc-gen/main.go

@@ -9,9 +9,6 @@ import (
 
 	"github.com/webrpc/webrpc"
 	"github.com/webrpc/webrpc/gen"
-	_ "github.com/webrpc/webrpc/gen/golang"
-	_ "github.com/webrpc/webrpc/gen/javascript"
-	_ "github.com/webrpc/webrpc/gen/typescript"
 )
 
 var flags = flag.NewFlagSet("webrpc-gen", flag.ExitOnError)
@@ -25,12 +22,7 @@ func main() {
 	clientFlag := flags.Bool("client", false, "enable webrpc client library generation, default: off")
 	serverFlag := flags.Bool("server", false, "enable webrpc server library generation, default: off")
 
-	// registered/available target languages
-	targets := []string{}
-	for k, _ := range gen.Generators {
-		targets = append(targets, k)
-	}
-	targetFlag := flags.String("target", "", fmt.Sprintf("target language for webrpc library generation, %s (required)", targets))
+	targetFlag := flags.String("target", "", fmt.Sprintf("target generator for webrpc library generation (required), ie. github.com/webrpc/gen-golang@v0.6.0"))
 	targetExtra := flags.String("extra", "", "target language extra/custom options")
 
 	flags.Parse(os.Args[1:])
@@ -69,27 +61,14 @@ func main() {
 		os.Exit(1)
 	}
 
-	targetLang := *targetFlag
-	if _, ok := gen.Generators[targetLang]; !ok {
-		fmt.Printf("oops, you passed an invalid -target flag, try one of registered generators: %s\n", targets)
-		os.Exit(1)
-	}
-
-	// Call our target code-generator
-	generator := gen.GetGenerator(*targetFlag)
-	if generator == nil {
-		fmt.Printf("error! unable to find generator for target '%s'\n", *targetFlag)
-		os.Exit(1)
-	}
-
 	targetOpts := gen.TargetOptions{
 		PkgName: *pkgFlag,
 		Client:  *clientFlag,
 		Server:  *serverFlag,
 		Extra:   *targetExtra,
 	}
 
-	protoGen, err := generator.Gen(schema, targetOpts)
+	protoGen, err := gen.Generate(schema, *targetFlag, targetOpts)
 	if err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)

gen/README.md

@@ -1,17 +1,4 @@
 # `gen` - webrpc code-generation for multiple language targets
 
-`gen` uses a basic templating language, along with the webrpc schema AST (abtract-syntax-tree)
+`gen` uses a Go [text/template](https://pkg.go.dev/text/template) language], along with the webrpc schema AST (abtract-syntax-tree)
 to generate source code of the Web service's type system, client library and server handlers.
-
-## Supported targets
-
-* `go` - [gen/golang](./golang)
-* `ts` - [gen/typescript](./typescript)
-* `js` - [gen/javascript](./javascript)
-
-
-## Adding a new target
-
-Adding a new target is easy, just add a folder under `gen/` and copy one of the existing
-targets and start adapting it for your language. Run `make build` to re-generate all templates
-and execute the code-generator via the `go:generate` in the target package you make.

gen/funcmap.go

@@ -0,0 +1,112 @@
+package gen
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/webrpc/webrpc/schema"
+)
+
+func templateFuncMap(proto *schema.WebRPCSchema, opts TargetOptions) map[string]interface{} {
+	return map[string]interface{}{
+		// Generic template functions.
+		"constPathPrefix": constPathPrefix,
+		"countMethods":    countMethods,
+		"commaIfLen":      commaIfLen,
+		"isStruct":        isStruct,
+		"isEnum":          isEnum,
+		"downcaseName":    downcaseName,
+		"listComma":       listComma,
+
+		// Golang specific template functions.
+		"goServiceMethodName":     goServiceMethodName,
+		"goServiceMethodJSONName": goServiceMethodJSONName,
+		"goHasGoFieldType":        goHasGoFieldType(proto),
+		"goFieldTags":             goFieldTags,
+		"goFieldType":             goFieldType,
+		"goFieldOptional":         goFieldOptional,
+		"goFieldTypeDef":          goFieldTypeDef,
+		"goNewClientServiceName":  goNewClientServiceName,
+		"goNewServerServiceName":  goNewServerServiceName,
+		"goClientServiceName":     goClientServiceName,
+		"goServerServiceName":     goServerServiceName,
+		"goMethodInputs":          goMethodInputs,
+		"goMethodOutputs":         goMethodOutputs,
+		"goMethodArgName":         goMethodArgName,
+		"goMethodArgType":         goMethodArgType,
+		"goMethodArgNames":        goMethodArgNames,
+		"goArgsList":              goArgsList,
+		"goExportedField":         goExportedField,
+
+		// TypeScript specific template functions.
+		"tsFieldType":                         tsFieldType,
+		"tsInterfaceName":                     tsInterfaceName,
+		"tsMethodName":                        tsMethodName,
+		"tsMethodInputs":                      tsMethodInputs,
+		"tsMethodOutputs":                     tsMethodOutputs,
+		"tsNewOutputArgResponse":              tsNewOutputArgResponse,
+		"tsMethodArgumentInputInterfaceName":  tsMethodArgumentInputInterfaceName,
+		"tsMethodArgumentOutputInterfaceName": tsMethodArgumentOutputInterfaceName,
+		"tsServiceInterfaceName":              tsServiceInterfaceName,
+		"tsExportableField":                   tsExportableField,
+		"tsExportedField":                     tsExportedField,
+		"tsExportedJSONField":                 tsExportedJSONField,
+		"jsFieldType":                         jsFieldType,
+
+		// JavaScript specific template functions.
+		"jsExportKeyword":        jsExportKeyword(opts),
+		"jsMethodName":           jsMethodName,
+		"jsMethodInputs":         jsMethodInputs,
+		"jsNewOutputArgResponse": jsNewOutputArgResponse,
+		"jsServiceInterfaceName": jsServiceInterfaceName,
+		"jsExportedJSONField":    jsExportedJSONField,
+	}
+}
+
+func commaIfLen(in []*schema.MethodArgument) string {
+	if len(in) > 0 {
+		return ","
+	}
+	return ""
+}
+
+func listComma(item int, count int) string {
+	if item+1 < count {
+		return ", "
+	}
+	return ""
+}
+
+func isStruct(t schema.MessageType) bool {
+	return t == "struct"
+}
+
+func isEnum(t schema.MessageType) bool {
+	return t == "enum"
+}
+
+func downcaseName(v interface{}) (string, error) {
+	downFn := func(s string) string {
+		if s == "" {
+			return ""
+		}
+		return strings.ToLower(s[0:1]) + s[1:]
+	}
+	switch t := v.(type) {
+	case schema.VarName:
+		return downFn(string(t)), nil
+	case string:
+		return downFn(t), nil
+	default:
+		return "", errors.New("downcaseFieldName, unknown arg type")
+	}
+}
+
+func constPathPrefix(in schema.VarName) (string, error) {
+	return string(in) + "PathPrefix", nil
+}
+
+func countMethods(in []*schema.Method) (string, error) {
+	return strconv.Itoa(len(in)), nil
+}