feat: generate the entire dota api

Author: paralin

README.md

@@ -20,12 +20,15 @@ Currently, the following client features have been implemented in this library:
  - [x] Player profile fetching / call tracking
  - [x] SOCache tracking / state management
  - [x] Basic chat interaction
- - [~] Lobby tracking / state management
+ - [x] Lobby tracking / state management
     - [x] Read lobby state correctly
-    - [ ] Implement normal lobby operations
- - [~] Party tracking / state management
+    - [x] Implement normal lobby operations
+ - [x] Party tracking / state management
     - [x] Read party and invite state correctly
-    - [ ] Implement normal party operations
+    - [x] Implement normal party operations
+ - [x] Code generation for API
+ - [ ] Code generation for events
+ - [ ] Less awkward comment generation / handwritten comments
 
 ... and others. This is the current short-term roadmap.
 
@@ -56,6 +59,14 @@ Events for the object type are emitted on the eventCh. Be sure to call `eventCan
 
 The cache object also adds interfaces to get and list the current objects in the cache.
 
+## Implementation Generation
+
+The base API implementation is generated by the [apigen](./apigen) code. Using heuristics, request IDs are matched to response IDs, and events and action-only requests are identified. Some manual tweaking is done in the overrides file.
+
+Next, the API information is used to build a Go code-gen set of implementations around the `MakeRequest` request tracking mechanism.
+
+This means that ALL of the Dota API will be available in this codebase, although only some of it is documented.
+
 ## go-steam Dependency
 
 This library depends on `go-steam`. Currently we are using the [FACEIT fork](https://github.com/faceit/go-steam).

apigen/.gitignore

@@ -0,0 +1 @@
+apigen

apigen/api_generate.go

@@ -0,0 +1,269 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"go/types"
+	"io"
+	"sort"
+	"strings"
+	"unicode"
+
+	gcm "github.com/paralin/go-dota2/protocol/dota_gcmessages_msgid"
+	"github.com/pkg/errors"
+	"github.com/serenize/snaker"
+)
+
+// GenerateAPI uses protobuf reflection to generate an API client for Dota.
+func GenerateAPI(ctx context.Context, clientOutput, eventsOutput io.Writer) error {
+	senderMap := make(map[gcm.EDOTAGCMsg]MsgSender)
+
+	packageMap, protoMap, err := BuildProtoTypeMap()
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(clientOutput, "package dota2\n\nimport (\n")
+
+	msgIds := getSortedMsgIDs()
+	var requestFuncs []*generatedRequestFunc
+
+	clientImports := make(map[string]struct{})
+	clientImports["context"] = struct{}{}
+	clientImports["github.com/paralin/go-dota2/protocol/dota_shared_enums"] = struct{}{}
+	clientImports["github.com/faceit/go-steam/steamid"] = struct{}{}
+	clientImports["github.com/paralin/go-dota2/protocol/dota_gcmessages_msgid"] = struct{}{}
+
+	eventsImports := make(map[string]struct{})
+	eventsImports["context"] = struct{}{}
+
+	// responseMsgs are messages that are known to be responses.
+	responseMsgs := make(map[gcm.EDOTAGCMsg]struct{})
+	// eventHandlers := make(map[gcm.EDOTAGCMsg]*generatedEventHandler)
+
+	for _, msgID := range msgIds {
+		sender := GetMessageSender(msgID)
+		if sender == MsgSenderNone {
+			continue
+		}
+
+		senderMap[msgID] = sender
+		if sender == MsgSenderClient {
+			genReqFunc, err := buildGeneratedRequestFunc(msgID, protoMap, clientImports)
+			if err != nil {
+				return err
+			}
+
+			if genReqFunc.respMsgID != 0 {
+				responseMsgs[genReqFunc.respMsgID] = struct{}{}
+			}
+
+			requestFuncs = append(requestFuncs, genReqFunc)
+		} /* else if sender == MsgSenderGC {
+			msgStr := msgID.String()
+			if strings.HasSuffix(msgStr, "Response") {
+				continue
+			}
+
+			eventHandler, err := buildGeneratedEventHandler(msgID, protoMap, eventsImports)
+			if err != nil {
+				return err
+			}
+
+			eventHandlers[msgID] = eventHandler
+		}*/
+	}
+
+	sort.Slice(requestFuncs, func(i int, j int) bool {
+		return requestFuncs[i].methodName < requestFuncs[j].methodName
+	})
+
+	for pakPath := range clientImports {
+		fmt.Fprintf(clientOutput, "\t\"%s\"\n", pakPath)
+	}
+
+	fmt.Fprintf(clientOutput, ")\n")
+
+	steamIDFieldOverrides := make(map[string]string)
+	for _, f := range requestFuncs {
+		fmt.Fprintf(clientOutput, "\n// %s\n", f.generateComment())
+		fmt.Fprintf(clientOutput, "func (d *Dota2) %s(\n", f.methodName)
+
+		respTyp := f.respType
+		if respTyp != nil {
+			fmt.Fprintf(clientOutput, "\tctx context.Context,\n")
+		}
+
+		reqTyp := f.reqType.Type()
+		reqTypUnderlying := reqTyp.Underlying()
+		reqDs := reqTypUnderlying.(*types.Struct)
+		reqFields := make(map[string]string)
+		var reqFieldsOrdered []string
+
+		reqObjAsArgument := reqDs.NumFields() > 8
+		if v, ok := msgArgAsParameterOverrides[f.reqMsgID]; ok {
+			reqObjAsArgument = v
+		}
+
+		if reqObjAsArgument {
+			fmt.Fprintf(clientOutput, "\treq *")
+			if err := printFieldType(clientOutput, reqTyp); err != nil {
+				return err
+			}
+			fmt.Fprintf(clientOutput, ",\n")
+		} else {
+			for i := 0; i < reqDs.NumFields(); i++ {
+				reqField := reqDs.Field(i)
+				if !reqField.Exported() {
+					continue
+				}
+
+				reqFieldName := reqField.Name()
+				if strings.HasPrefix(reqFieldName, "XXX_") {
+					continue
+				}
+
+				reqFieldNameUpper := reqFieldName
+				reqFieldName = snaker.SnakeToCamel(reqFieldName)
+				reqFieldName = string(append([]rune{unicode.ToLower([]rune(reqFieldName)[0])}, []rune(reqFieldName[1:])...))
+				switch reqFieldName {
+				case "map":
+					reqFieldName = "gameMap"
+				case "clientVersion":
+					continue
+				}
+
+				reqFieldName = strings.Replace(reqFieldName, "Id", "ID", -1)
+
+				_, isSlice := reqField.Type().(*types.Slice)
+				if isSlice {
+					if _, ok := reqFields[reqFieldName]; !ok {
+						reqFieldsOrdered = append(reqFieldsOrdered, reqFieldName)
+					}
+					reqFields[reqFieldName] = reqFieldNameUpper
+				} else {
+					if _, ok := reqFields["&"+reqFieldName]; !ok {
+						reqFieldsOrdered = append(reqFieldsOrdered, "&"+reqFieldName)
+					}
+					reqFields["&"+reqFieldName] = reqFieldNameUpper
+				}
+
+				reqFieldType := reqField.Type()
+				reqFieldTypePtr, isPtr := reqFieldType.(*types.Pointer)
+				if isPtr {
+					reqFieldType = reqFieldTypePtr.Elem()
+				}
+
+				if !isSlice &&
+					strings.Contains(strings.ToLower(reqFieldName), "steamid") &&
+					strings.Contains(reqFieldType.String(), "uint64") {
+					reqFieldType = types.NewNamed(
+						types.NewTypeName(
+							0,
+							packageMap["github.com/faceit/go-steam/steamid"],
+							"SteamId",
+							reqFieldType,
+						),
+						reqFieldType,
+						nil,
+					)
+					reqFieldNameAfter := reqFieldName + "U64"
+					if _, ok := reqFields[reqFieldNameAfter]; !ok {
+						reqFieldsOrdered = append(reqFieldsOrdered, reqFieldNameAfter)
+					}
+					steamIDFieldOverrides[reqFieldNameAfter] = reqFieldName
+					delete(reqFields, "&"+reqFieldName)
+					reqFields[reqFieldNameAfter] = reqFieldNameUpper
+				}
+
+				fmt.Fprintf(clientOutput, "\t%s ", reqFieldName)
+				if err := printFieldType(clientOutput, reqFieldType); err != nil {
+					return err
+				}
+				fmt.Fprintf(clientOutput, ",\n")
+			}
+		}
+
+		fmt.Fprintf(clientOutput, ") ")
+
+		if respTyp != nil {
+			fmt.Fprintf(clientOutput, "(*")
+			if err := printFieldType(clientOutput, respTyp.Type()); err != nil {
+				return err
+			}
+			fmt.Fprintf(clientOutput, ", error) ")
+		}
+		fmt.Fprintf(clientOutput, "{\n")
+
+		// transform steam IDs
+		for _, fieldName := range reqFieldsOrdered {
+			if _, ok := reqFields[fieldName]; !ok {
+				continue
+			}
+
+			if sidOverride, ok := steamIDFieldOverrides[fieldName]; ok {
+				fmt.Fprintf(clientOutput, "\t%sVal := uint64(%s)\n", fieldName, sidOverride)
+				fmt.Fprintf(clientOutput, "\t%s := &%sVal\n", fieldName, fieldName)
+			}
+		}
+
+		if !reqObjAsArgument {
+			fmt.Fprintf(clientOutput, "\treq := &")
+			if err := printFieldType(clientOutput, reqTyp); err != nil {
+				return err
+			}
+			fmt.Fprintf(clientOutput, "{")
+			for _, fieldName := range reqFieldsOrdered {
+				fieldNameUpper, ok := reqFields[fieldName]
+				if !ok {
+					continue
+				}
+
+				fmt.Fprintf(clientOutput, "\n\t\t%s: %s,", fieldNameUpper, fieldName)
+			}
+			if len(reqFields) != 0 {
+				fmt.Fprintf(clientOutput, "\n\t")
+			}
+			fmt.Fprintf(clientOutput, "}\n")
+		}
+
+		if respTyp != nil {
+			fmt.Fprintf(clientOutput, "\tresp := &")
+			if err := printFieldType(clientOutput, respTyp.Type()); err != nil {
+				return err
+			}
+			fmt.Fprintf(clientOutput, "{}\n\n\treturn resp, d.MakeRequest(\n")
+			fmt.Fprintf(clientOutput, "\t\tctx,\n\t\tuint32(dota_gcmessages_msgid.EDOTAGCMsg_%s),\n", f.reqMsgID.String())
+			fmt.Fprintf(clientOutput, "\t\treq,\n\t\tuint32(dota_gcmessages_msgid.EDOTAGCMsg_%s),\n", f.respMsgID.String())
+			fmt.Fprintf(clientOutput, "\t\tresp,\n\t)\n")
+		} else {
+			fmt.Fprintf(clientOutput, "\td.write(uint32(dota_gcmessages_msgid.EDOTAGCMsg_%s), req)\n", f.reqMsgID.String())
+		}
+
+		fmt.Fprintf(clientOutput, "}\n")
+	}
+
+	return nil
+}
+
+func printFieldType(output io.Writer, reqFieldType types.Type) error {
+	switch rft := reqFieldType.(type) {
+	case *types.Basic:
+		fmt.Fprintf(output, "%s", rft.Name())
+	case *types.Pointer:
+		fmt.Fprintf(output, "*")
+		return printFieldType(output, rft.Elem())
+	case *types.Named:
+		pkgName := rft.Obj().Pkg().Name()
+		typName := rft.Obj().Name()
+		fmt.Fprintf(output, "%s.%s", pkgName, typName)
+	case *types.Slice:
+		elemType := rft.Elem()
+		fmt.Fprintf(output, "[]")
+		return printFieldType(output, elemType)
+	default:
+		return errors.Errorf("type unhandled: %#v", reqFieldType)
+	}
+
+	return nil
+}

apigen/api_generate_event.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	gcm "github.com/paralin/go-dota2/protocol/dota_gcmessages_msgid"
+)
+
+type generatedEventHandler struct {
+	msgID     gcm.EDOTAGCMsg
+	eventName string
+	eventType *ProtoType
+}
+
+// buildGeneratedEventHandler builds a generated event handler.
+func buildGeneratedEventHandler(
+	msgID gcm.EDOTAGCMsg,
+	protoMap map[string]*ProtoType,
+	eventImports map[string]struct{},
+) (*generatedEventHandler, error) {
+	eventProtoType, err := LookupMessageProtoType(protoMap, msgID)
+	if err != nil {
+		return nil, err
+	}
+	eventImports[eventProtoType.Pak.Path()] = struct{}{}
+
+	return &generatedEventHandler{
+		msgID:     msgID,
+		eventName: GetMessageEventName(msgID),
+		eventType: eventProtoType,
+	}, nil
+}