feat(backend/mobs): clean up ruby templates and final generated code (#851)

backend/pkg/messages/message.go

@@ -4,7 +4,6 @@ import "fmt"
 
 type Message interface {
 	Encode() []byte
-	EncodeWithIndex() []byte
 	Decode() Message
 	TypeID() int
 	Meta() *message

backend/pkg/messages/primitives.go

@@ -1,11 +1,9 @@
 package messages
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
-	"log"
 )
 
 var (
@@ -21,19 +19,6 @@ func ReadByte(reader io.Reader) (byte, error) {
 	return one[0], nil
 }
 
-func ReadData(reader io.Reader) ([]byte, error) {
-	n, err := ReadUint(reader)
-	if err != nil {
-		return nil, err
-	}
-	p := make([]byte, n)
-	_, err = io.ReadFull(reader, p)
-	if err != nil {
-		return nil, err
-	}
-	return p, nil
-}
-
 func ReadUint(reader io.Reader) (uint64, error) {
 	var x uint64
 	var s uint
@@ -55,6 +40,16 @@ func ReadUint(reader io.Reader) (uint64, error) {
 	}
 }
 
+func WriteUint(v uint64, buf []byte, p int) int {
+	for v >= 0x80 {
+		buf[p] = byte(v) | 0x80
+		v >>= 7
+		p++
+	}
+	buf[p] = byte(v)
+	return p + 1
+}
+
 func ReadInt(reader io.Reader) (int64, error) {
 	ux, err := ReadUint(reader)
 	x := int64(ux >> 1)
@@ -67,6 +62,14 @@ func ReadInt(reader io.Reader) (int64, error) {
 	return x, err
 }
 
+func WriteInt(v int64, buf []byte, p int) int {
+	uv := uint64(v) << 1
+	if v < 0 {
+		uv = ^uv
+	}
+	return WriteUint(uv, buf, p)
+}
+
 func ReadBoolean(reader io.Reader) (bool, error) {
 	p := make([]byte, 1)
 	_, err := io.ReadFull(reader, p)
@@ -76,6 +79,15 @@ func ReadBoolean(reader io.Reader) (bool, error) {
 	return p[0] == 1, nil
 }
 
+func WriteBoolean(v bool, buf []byte, p int) int {
+	if v {
+		buf[p] = 1
+	} else {
+		buf[p] = 0
+	}
+	return p + 1
+}
+
 func ReadString(reader io.Reader) (string, error) {
 	l, err := ReadUint(reader)
 	if err != nil {
@@ -92,73 +104,11 @@ func ReadString(reader io.Reader) (string, error) {
 	return string(buf), nil
 }
 
-func ReadJson(reader io.Reader) (interface{}, error) {
-	jsonData, err := ReadData(reader)
-	if err != nil {
-		return nil, err
-	}
-	var v interface{}
-	if err = json.Unmarshal(jsonData, &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-func WriteUint(v uint64, buf []byte, p int) int {
-	for v >= 0x80 {
-		buf[p] = byte(v) | 0x80
-		v >>= 7
-		p++
-	}
-	buf[p] = byte(v)
-	return p + 1
-}
-
-func WriteInt(v int64, buf []byte, p int) int {
-	uv := uint64(v) << 1
-	if v < 0 {
-		uv = ^uv
-	}
-	return WriteUint(uv, buf, p)
-}
-
-func WriteBoolean(v bool, buf []byte, p int) int {
-	if v {
-		buf[p] = 1
-	} else {
-		buf[p] = 0
-	}
-	return p + 1
-}
-
 func WriteString(str string, buf []byte, p int) int {
 	p = WriteUint(uint64(len(str)), buf, p)
 	return p + copy(buf[p:], str)
 }
 
-func WriteData(data []byte, buf []byte, p int) int {
-	p = WriteUint(uint64(len(data)), buf, p)
-	return p + copy(buf[p:], data)
-}
-
-func WriteJson(v interface{}, buf []byte, p int) int {
-	data, err := json.Marshal(v)
-	if err != nil {
-		log.Printf("JSON encoding error: %v", err)
-		return WriteString("null", buf, p)
-	}
-	return WriteData(data, buf, p)
-}
-
-func WriteSize(size uint64, buf []byte, p int) {
-	var m uint64 = 255
-	for i := 0; i < 3; i++ {
-		buf[p+i] = byte(size & m)
-		size = size >> 8
-	}
-	fmt.Println(buf)
-}
-
 func ReadSize(reader io.Reader) (uint64, error) {
 	n, err := io.ReadFull(reader, three)
 	if err != nil {

backend/pkg/messages/raw.go

@@ -2,7 +2,6 @@ package messages
 
 import (
 	"bytes"
-	"encoding/binary"
 	"io"
 	"log"
 )
@@ -46,22 +45,6 @@ func (m *RawMessage) Encode() []byte {
 	return m.data
 }
 
-func (m *RawMessage) EncodeWithIndex() []byte {
-	if !m.encoded {
-		if m.Encode() == nil {
-			*m.broken = true
-			return nil
-		}
-	}
-	if IsIOSType(int(m.tp)) {
-		return m.data
-	}
-	data := make([]byte, len(m.data)+8)
-	copy(data[8:], m.data[:])
-	binary.LittleEndian.PutUint64(data[0:], m.Meta().Index)
-	return data
-}
-
 func (m *RawMessage) Decode() Message {
 	if !m.encoded {
 		if m.Encode() == nil {

backend/pkg/messages/read-message.go

@@ -1752,304 +1752,204 @@ func DecodeIOSIssueEvent(reader io.Reader) (Message, error) {
 
 func ReadMessage(t uint64, reader io.Reader) (Message, error) {
 	switch t {
-
 	case 80:
 		return DecodeBatchMeta(reader)
-
 	case 81:
 		return DecodeBatchMetadata(reader)
-
 	case 82:
 		return DecodePartitionedMessage(reader)
-
 	case 0:
 		return DecodeTimestamp(reader)
-
 	case 1:
 		return DecodeSessionStart(reader)
-
 	case 3:
 		return DecodeSessionEndDeprecated(reader)
-
 	case 4:
 		return DecodeSetPageLocation(reader)
-
 	case 5:
 		return DecodeSetViewportSize(reader)
-
 	case 6:
 		return DecodeSetViewportScroll(reader)
-
 	case 7:
 		return DecodeCreateDocument(reader)
-
 	case 8:
 		return DecodeCreateElementNode(reader)
-
 	case 9:
 		return DecodeCreateTextNode(reader)
-
 	case 10:
 		return DecodeMoveNode(reader)
-
 	case 11:
 		return DecodeRemoveNode(reader)
-
 	case 12:
 		return DecodeSetNodeAttribute(reader)
-
 	case 13:
 		return DecodeRemoveNodeAttribute(reader)
-
 	case 14:
 		return DecodeSetNodeData(reader)
-
 	case 15:
 		return DecodeSetCSSData(reader)
-
 	case 16:
 		return DecodeSetNodeScroll(reader)
-
 	case 17:
 		return DecodeSetInputTarget(reader)
-
 	case 18:
 		return DecodeSetInputValue(reader)
-
 	case 19:
 		return DecodeSetInputChecked(reader)
-
 	case 20:
 		return DecodeMouseMove(reader)
-
 	case 22:
 		return DecodeConsoleLog(reader)
-
 	case 23:
 		return DecodePageLoadTiming(reader)
-
 	case 24:
 		return DecodePageRenderTiming(reader)
-
 	case 25:
 		return DecodeJSExceptionDeprecated(reader)
-
 	case 26:
 		return DecodeIntegrationEvent(reader)
-
 	case 27:
 		return DecodeRawCustomEvent(reader)
-
 	case 28:
 		return DecodeUserID(reader)
-
 	case 29:
 		return DecodeUserAnonymousID(reader)
-
 	case 30:
 		return DecodeMetadata(reader)
-
 	case 31:
 		return DecodePageEvent(reader)
-
 	case 32:
 		return DecodeInputEvent(reader)
-
 	case 33:
 		return DecodeClickEvent(reader)
-
 	case 35:
 		return DecodeResourceEvent(reader)
-
 	case 36:
 		return DecodeCustomEvent(reader)
-
 	case 37:
 		return DecodeCSSInsertRule(reader)
-
 	case 38:
 		return DecodeCSSDeleteRule(reader)
-
 	case 39:
 		return DecodeFetch(reader)
-
 	case 40:
 		return DecodeProfiler(reader)
-
 	case 41:
 		return DecodeOTable(reader)
-
 	case 42:
 		return DecodeStateAction(reader)
-
 	case 43:
 		return DecodeStateActionEvent(reader)
-
 	case 44:
 		return DecodeRedux(reader)
-
 	case 45:
 		return DecodeVuex(reader)
-
 	case 46:
 		return DecodeMobX(reader)
-
 	case 47:
 		return DecodeNgRx(reader)
-
 	case 48:
 		return DecodeGraphQL(reader)
-
 	case 49:
 		return DecodePerformanceTrack(reader)
-
 	case 50:
 		return DecodeGraphQLEvent(reader)
-
 	case 51:
 		return DecodeFetchEvent(reader)
-
 	case 52:
 		return DecodeDOMDrop(reader)
-
 	case 53:
 		return DecodeResourceTiming(reader)
-
 	case 54:
 		return DecodeConnectionInformation(reader)
-
 	case 55:
 		return DecodeSetPageVisibility(reader)
-
 	case 56:
 		return DecodePerformanceTrackAggr(reader)
-
 	case 57:
 		return DecodeLoadFontFace(reader)
-
 	case 58:
 		return DecodeSetNodeFocus(reader)
-
 	case 59:
 		return DecodeLongTask(reader)
-
 	case 60:
 		return DecodeSetNodeAttributeURLBased(reader)
-
 	case 61:
 		return DecodeSetCSSDataURLBased(reader)
-
 	case 62:
 		return DecodeIssueEvent(reader)
-
 	case 63:
 		return DecodeTechnicalInfo(reader)
-
 	case 64:
 		return DecodeCustomIssue(reader)
-
 	case 66:
 		return DecodeAssetCache(reader)
-
 	case 67:
 		return DecodeCSSInsertRuleURLBased(reader)
-
 	case 69:
 		return DecodeMouseClick(reader)
-
 	case 70:
 		return DecodeCreateIFrameDocument(reader)
-
 	case 71:
 		return DecodeAdoptedSSReplaceURLBased(reader)
-
 	case 72:
 		return DecodeAdoptedSSReplace(reader)
-
 	case 73:
 		return DecodeAdoptedSSInsertRuleURLBased(reader)
-
 	case 74:
 		return DecodeAdoptedSSInsertRule(reader)
-
 	case 75:
 		return DecodeAdoptedSSDeleteRule(reader)
-
 	case 76:
 		return DecodeAdoptedSSAddOwner(reader)
-
 	case 77:
 		return DecodeAdoptedSSRemoveOwner(reader)
-
 	case 79:
 		return DecodeZustand(reader)
-
 	case 78:
 		return DecodeJSException(reader)
-
 	case 126:
 		return DecodeSessionEnd(reader)
-
 	case 127:
 		return DecodeSessionSearch(reader)
-
 	case 107:
 		return DecodeIOSBatchMeta(reader)
-
 	case 90:
 		return DecodeIOSSessionStart(reader)
-
 	case 91:
 		return DecodeIOSSessionEnd(reader)
-
 	case 92:
 		return DecodeIOSMetadata(reader)
-
 	case 93:
 		return DecodeIOSCustomEvent(reader)
-
 	case 94:
 		return DecodeIOSUserID(reader)
-
 	case 95:
 		return DecodeIOSUserAnonymousID(reader)
-
 	case 96:
 		return DecodeIOSScreenChanges(reader)
-
 	case 97:
 		return DecodeIOSCrash(reader)
-
 	case 98:
 		return DecodeIOSScreenEnter(reader)
-
 	case 99:
 		return DecodeIOSScreenLeave(reader)
-
 	case 100:
 		return DecodeIOSClickEvent(reader)
-
 	case 101:
 		return DecodeIOSInputEvent(reader)
-
 	case 102:
 		return DecodeIOSPerformanceEvent(reader)
-
 	case 103:
 		return DecodeIOSLog(reader)
-
 	case 104:
 		return DecodeIOSInternalError(reader)
-
 	case 105:
 		return DecodeIOSNetworkCall(reader)
-
 	case 110:
 		return DecodeIOSPerformanceAggregated(reader)
-
 	case 111:
 		return DecodeIOSIssueEvent(reader)
-
 	}
 	return nil, fmt.Errorf("Unknown message code: %v", t)
 }

mobs/primitives/primitives.go

@@ -2,38 +2,21 @@ package messages
 
 import (
 	"errors"
+	"fmt"
 	"io"
 )
 
+var (
+	one   = []byte{0}
+	three = []byte{0, 0, 0}
+)
+
 func ReadByte(reader io.Reader) (byte, error) {
-	p := make([]byte, 1)
-	_, err := io.ReadFull(reader, p)
+	_, err := io.ReadFull(reader, one)
 	if err != nil {
 		return 0, err
 	}
-	return p[0], nil
-}
-
-func SkipBytes(reader io.ReadSeeker) error {
-	n, err := ReadUint(reader)
-	if err != nil {
-		return err
-	}
-	_, err = reader.Seek(int64(n), io.SeekCurrent)
-	return err
-}
-
-func ReadData(reader io.Reader) ([]byte, error) {
-	n, err := ReadUint(reader)
-	if err != nil {
-		return nil, err
-	}
-	p := make([]byte, n)
-	_, err = io.ReadFull(reader, p)
-	if err != nil {
-		return nil, err
-	}
-	return p, nil
+	return one[0], nil
 }
 
 func ReadUint(reader io.Reader) (uint64, error) {
@@ -47,7 +30,7 @@ func ReadUint(reader io.Reader) (uint64, error) {
 		}
 		if b < 0x80 {
 			if i > 9 || i == 9 && b > 1 {
-				return x, errors.New("overflow")
+				return x, errors.New("uint overflow")
 			}
 			return x | uint64(b)<<s, nil
 		}
@@ -57,6 +40,16 @@ func ReadUint(reader io.Reader) (uint64, error) {
 	}
 }
 
+func WriteUint(v uint64, buf []byte, p int) int {
+	for v >= 0x80 {
+		buf[p] = byte(v) | 0x80
+		v >>= 7
+		p++
+	}
+	buf[p] = byte(v)
+	return p + 1
+}
+
 func ReadInt(reader io.Reader) (int64, error) {
 	ux, err := ReadUint(reader)
 	x := int64(ux >> 1)
@@ -69,6 +62,14 @@ func ReadInt(reader io.Reader) (int64, error) {
 	return x, err
 }
 
+func WriteInt(v int64, buf []byte, p int) int {
+	uv := uint64(v) << 1
+	if v < 0 {
+		uv = ^uv
+	}
+	return WriteUint(uv, buf, p)
+}
+
 func ReadBoolean(reader io.Reader) (bool, error) {
 	p := make([]byte, 1)
 	_, err := io.ReadFull(reader, p)
@@ -78,37 +79,6 @@ func ReadBoolean(reader io.Reader) (bool, error) {
 	return p[0] == 1, nil
 }
 
-func ReadString(reader io.Reader) (string, error) {
-	l, err := ReadUint(reader)
-	if err != nil {
-		return "", err
-	}
-	buf := make([]byte, l)
-	_, err = io.ReadFull(reader, buf)
-	if err != nil {
-		return "", err
-	}
-	return string(buf), nil
-}
-
-func WriteUint(v uint64, buf []byte, p int) int {
-	for v >= 0x80 {
-		buf[p] = byte(v) | 0x80
-		v >>= 7
-		p++
-	}
-	buf[p] = byte(v)
-	return p + 1
-}
-
-func WriteInt(v int64, buf []byte, p int) int {
-	uv := uint64(v) << 1
-	if v < 0 {
-		uv = ^uv
-	}
-	return WriteUint(uv, buf, p)
-}
-
 func WriteBoolean(v bool, buf []byte, p int) int {
 	if v {
 		buf[p] = 1
@@ -118,7 +88,38 @@ func WriteBoolean(v bool, buf []byte, p int) int {
 	return p + 1
 }
 
+func ReadString(reader io.Reader) (string, error) {
+	l, err := ReadUint(reader)
+	if err != nil {
+		return "", err
+	}
+	if l > 10e6 {
+		return "", errors.New("Too long string")
+	}
+	buf := make([]byte, l)
+	_, err = io.ReadFull(reader, buf)
+	if err != nil {
+		return "", err
+	}
+	return string(buf), nil
+}
+
 func WriteString(str string, buf []byte, p int) int {
 	p = WriteUint(uint64(len(str)), buf, p)
 	return p + copy(buf[p:], str)
 }
+
+func ReadSize(reader io.Reader) (uint64, error) {
+	n, err := io.ReadFull(reader, three)
+	if err != nil {
+		return 0, err
+	}
+	if n != 3 {
+		return 0, fmt.Errorf("read only %d of 3 size bytes", n)
+	}
+	var size uint64
+	for i, b := range three {
+		size += uint64(b) << (8 * i)
+	}
+	return size, nil
+}

mobs/templates/backend~pkg~messages~messages.go.erb

@@ -1,12 +1,8 @@
 // Auto-generated, do not edit
 package messages
 
-import "encoding/binary"
-
-const (
-<% $messages.each do |msg| %>
-    Msg<%= msg.name %> = <%= msg.id %>
-<% end %>
+const (<% $messages.each do |msg| %>
+    Msg<%= msg.name %> = <%= msg.id %><% end %>
 )
 
 <% $messages.each do |msg| %>
@@ -25,17 +21,6 @@ func (msg *<%= msg.name %>) Encode() []byte {
 	return buf[:p]
 }
 
-func (msg *<%= msg.name %>) EncodeWithIndex() []byte {
-    encoded := msg.Encode()
-    if IsIOSType(msg.TypeID()) {
-        return encoded
-    }
-    data := make([]byte, len(encoded)+8)
-    copy(data[8:], encoded[:])
-    binary.LittleEndian.PutUint64(data[0:], msg.Meta().Index)
-    return data
-}
-
 func (msg *<%= msg.name %>) Decode() Message {
 	return msg
 }

mobs/templates/backend~pkg~messages~read-message.go.erb

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 )
-
 <% $messages.each do |msg| %>
 func Decode<%= msg.name %>(reader io.Reader) (Message, error) {
     var err error = nil
@@ -16,15 +15,11 @@ func Decode<%= msg.name %>(reader io.Reader) (Message, error) {
         }" }.join "\n" %>
         return msg, err
 }
-
 <% end %>
-
 func ReadMessage(t uint64, reader io.Reader) (Message, error) {
-	switch t {
-<% $messages.each do |msg| %>
+	switch t {<% $messages.each do |msg| %>
 	case <%= msg.id %>:
-		return Decode<%= msg.name %>(reader)
-<% end %>
+		return Decode<%= msg.name %>(reader)<% end %>
 	}
 	return nil, fmt.Errorf("Unknown message code: %v", t)
 }