refactor(transports/ipc): cleaner decode function

Author: NotSugden

src/transports/ipc.js

@@ -14,91 +14,86 @@ const OPCodes = {
   PONG: 4,
 };
 
-function getIPCPath(id) {
+const getIPCPath = (id) => {
   if (process.platform === 'win32') {
     return `\\\\?\\pipe\\discord-ipc-${id}`;
   }
   const { env: { XDG_RUNTIME_DIR, TMPDIR, TMP, TEMP } } = process;
   const prefix = XDG_RUNTIME_DIR || TMPDIR || TMP || TEMP || '/tmp';
   return `${prefix.replace(/\/$/, '')}/discord-ipc-${id}`;
-}
+};
 
-function getIPC(id = 0) {
-  return new Promise((resolve, reject) => {
-    const path = getIPCPath(id);
-    const onError = () => {
-      if (id < 10) {
-        resolve(getIPC(id + 1));
-      } else {
-        reject(new Error('COULD_NOT_CONNECT'));
-      }
-    };
-    const socket = net.createConnection(path, () => {
-      socket.removeListener('error', onError);
-      resolve(socket);
-    });
-    socket.once('error', onError);
+const getIPC = (id = 0) => new Promise((resolve, reject) => {
+  const path = getIPCPath(id);
+  const onError = () => {
+    if (id < 10) {
+      resolve(getIPC(id + 1));
+    } else {
+      reject(new Error('COULD_NOT_CONNECT'));
+    }
+  };
+  const socket = net.createConnection(path, () => {
+    socket.removeListener('error', onError);
+    resolve(socket);
   });
-}
+  socket.once('error', onError);
+});
 
-async function findEndpoint(tries = 0) {
+const findEndpoint = async (tries = 0) => {
   if (tries > 30) {
     throw new Error('COULD_NOT_FIND_ENDPOINT');
   }
   const endpoint = `http://127.0.0.1:${6463 + (tries % 10)}`;
   try {
-    const r = await fetch(endpoint);
-    if (r.status === 404) {
+    const response = await fetch(endpoint);
+    if (response.status === 404) {
       return endpoint;
     }
-    return findEndpoint(tries + 1);
-  } catch (e) {
-    return findEndpoint(tries + 1);
-  }
-}
+  } catch { } // eslint-disable-line no-empty
+  return findEndpoint(tries + 1);
+};
 
-function encode(op, data) {
+const encode = (op, data) => {
   data = JSON.stringify(data);
-  const len = Buffer.byteLength(data);
-  const packet = Buffer.alloc(8 + len);
+  const length = Buffer.byteLength(data);
+  const packet = Buffer.alloc(length + 8);
   packet.writeInt32LE(op, 0);
-  packet.writeInt32LE(len, 4);
-  packet.write(data, 8, len);
+  packet.writeInt32LE(length, 4);
+  packet.write(data, 8, length);
   return packet;
-}
-
-const working = {
-  full: '',
-  op: undefined,
 };
 
-function decode(socket, callback) {
-  const packet = socket.read();
-  if (!packet) {
-    return;
-  }
+const decode = (socket) => {
+  let op;
+  let jsonString = '';
 
-  let { op } = working;
-  let raw;
-  if (working.full === '') {
-    op = working.op = packet.readInt32LE(0);
-    const len = packet.readInt32LE(4);
-    raw = packet.slice(8, len + 8);
-  } else {
-    raw = packet.toString();
-  }
+  const read = () => {
+    const packet = socket.read();
+    if (!packet) {
+      return null;
+    }
+    let part;
+
+    if (jsonString === '') {
+      op = packet.readInt32LE(0);
+      const length = packet.readInt32LE(4);
+      part = packet.slice(8, length + 8);
+    } else {
+      part = packet.toString();
+    }
 
-  try {
-    const data = JSON.parse(working.full + raw);
-    callback({ op, data }); // eslint-disable-line callback-return
-    working.full = '';
-    working.op = undefined;
-  } catch (err) {
-    working.full += raw;
-  }
+    jsonString += part;
 
-  decode(socket, callback);
-}
+    try {
+      const data = JSON.parse(jsonString);
+      return { data, op };
+    } catch {
+      return read();
+    }
+  };
+
+  return read();
+};
 
 class IPCTransport extends EventEmitter {
   constructor(client) {
@@ -109,6 +104,7 @@ class IPCTransport extends EventEmitter {
 
   async connect() {
     const socket = this.socket = await getIPC();
+
     socket.on('close', this.onClose.bind(this));
     socket.on('error', this.onClose.bind(this));
     this.emit('open');
@@ -118,33 +114,36 @@ class IPCTransport extends EventEmitter {
     }));
     socket.pause();
     socket.on('readable', () => {
-      decode(socket, ({ op, data }) => {
-        switch (op) {
-          case OPCodes.PING:
-            this.send(data, OPCodes.PONG);
-            break;
-          case OPCodes.FRAME:
-            if (!data) {
-              return;
-            }
-            if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') {
-              findEndpoint()
-                .then((endpoint) => {
-                  this.client.request.endpoint = endpoint;
-                })
-                .catch((error) => {
-                  this.client.emit('error', error);
-                });
-            }
-            this.emit('message', data);
-            break;
-          case OPCodes.CLOSE:
-            this.emit('close', data);
-            break;
-          default:
-            break;
-        }
-      });
+      const decoded = decode(socket);
+      if (!decoded) {
+        return;
+      }
+      const { data, op } = decoded;
+      switch (op) {
+        case OPCodes.PING:
+          this.send(data, OPCodes.PONG);
+          break;
+        case OPCodes.FRAME:
+          if (!data) {
+            return;
+          }
+          if (data.cmd === 'AUTHORIZE' && data.evt !== 'ERROR') {
+            findEndpoint()
+              .then((endpoint) => {
+                this.client.request.endpoint = endpoint;
+              })
+              .catch((error) => {
+                this.client.emit('error', error);
+              });
+          }
+          this.emit('message', data);
+          break;
+        case OPCodes.CLOSE:
+          this.emit('close', data);
+          break;
+        default:
+          break;
+      }
     });
   }