refactor: remove "self" references

Author: darrachequesne

lib/socket.js

@@ -172,9 +172,8 @@ class Socket extends Emitter {
       transport = "websocket";
     } else if (0 === this.transports.length) {
       // Emit error on next tick so it can be listened to
-      const self = this;
-      setTimeout(function() {
-        self.emit("error", "No transports available");
+      setTimeout(() => {
+        this.emit("error", "No transports available");
       }, 0);
       return;
     } else {
@@ -203,7 +202,6 @@ class Socket extends Emitter {
    */
   setTransport(transport) {
     debug("setting transport %s", transport.name);
-    const self = this;
 
     if (this.transport) {
       debug("clearing existing transport %s", this.transport.name);
@@ -215,17 +213,11 @@ class Socket extends Emitter {
 
     // set up transport listeners
     transport
-      .on("drain", function() {
-        self.onDrain();
-      })
-      .on("packet", function(packet) {
-        self.onPacket(packet);
-      })
-      .on("error", function(e) {
-        self.onError(e);
-      })
-      .on("close", function() {
-        self.onClose("transport close");
+      .on("drain", this.onDrain.bind(this))
+      .on("packet", this.onPacket.bind(this))
+      .on("error", this.onError.bind(this))
+      .on("close", () => {
+        this.onClose("transport close");
       });
   }
 
@@ -239,52 +231,46 @@ class Socket extends Emitter {
     debug('probing transport "%s"', name);
     let transport = this.createTransport(name, { probe: 1 });
     let failed = false;
-    const self = this;
 
     Socket.priorWebsocketSuccess = false;
 
-    function onTransportOpen() {
-      if (self.onlyBinaryUpgrades) {
-        const upgradeLosesBinary =
-          !this.supportsBinary && self.transport.supportsBinary;
-        failed = failed || upgradeLosesBinary;
-      }
+    const onTransportOpen = () => {
       if (failed) return;
 
       debug('probe transport "%s" opened', name);
       transport.send([{ type: "ping", data: "probe" }]);
-      transport.once("packet", function(msg) {
+      transport.once("packet", msg => {
         if (failed) return;
         if ("pong" === msg.type && "probe" === msg.data) {
           debug('probe transport "%s" pong', name);
-          self.upgrading = true;
-          self.emit("upgrading", transport);
+          this.upgrading = true;
+          this.emit("upgrading", transport);
           if (!transport) return;
           Socket.priorWebsocketSuccess = "websocket" === transport.name;
 
-          debug('pausing current transport "%s"', self.transport.name);
-          self.transport.pause(function() {
+          debug('pausing current transport "%s"', this.transport.name);
+          this.transport.pause(() => {
             if (failed) return;
-            if ("closed" === self.readyState) return;
+            if ("closed" === this.readyState) return;
             debug("changing transport and sending upgrade packet");
 
             cleanup();
 
-            self.setTransport(transport);
+            this.setTransport(transport);
             transport.send([{ type: "upgrade" }]);
-            self.emit("upgrade", transport);
+            this.emit("upgrade", transport);
             transport = null;
-            self.upgrading = false;
-            self.flush();
+            this.upgrading = false;
+            this.flush();
           });
         } else {
           debug('probe transport "%s" failed', name);
           const err = new Error("probe error");
           err.transport = transport.name;
-          self.emit("upgradeError", err);
+          this.emit("upgradeError", err);
         }
       });
-    }
+    };
 
     function freezeTransport() {
       if (failed) return;
@@ -299,16 +285,16 @@ class Socket extends Emitter {
     }
 
     // Handle any error that happens while probing
-    function onerror(err) {
+    const onerror = err => {
       const error = new Error("probe error: " + err);
       error.transport = transport.name;
 
       freezeTransport();
 
       debug('probe transport "%s" failed because of error: %s', name, err);
 
-      self.emit("upgradeError", error);
-    }
+      this.emit("upgradeError", error);
+    };
 
     function onTransportClose() {
       onerror("transport closed");
@@ -328,13 +314,13 @@ class Socket extends Emitter {
     }
 
     // Remove all listeners on the transport and on self
-    function cleanup() {
+    const cleanup = () => {
       transport.removeListener("open", onTransportOpen);
       transport.removeListener("error", onerror);
       transport.removeListener("close", onTransportClose);
-      self.removeListener("close", onclose);
-      self.removeListener("upgrading", onupgrade);
-    }
+      this.removeListener("close", onclose);
+      this.removeListener("upgrading", onupgrade);
+    };
 
     transport.once("open", onTransportOpen);
     transport.once("error", onerror);
@@ -557,13 +543,29 @@ class Socket extends Emitter {
    * @api private
    */
   close() {
-    const self = this;
+    const close = () => {
+      this.onClose("forced close");
+      debug("socket closing - telling transport to close");
+      this.transport.close();
+    };
+
+    const cleanupAndClose = () => {
+      this.removeListener("upgrade", cleanupAndClose);
+      this.removeListener("upgradeError", cleanupAndClose);
+      close();
+    };
+
+    const waitForUpgrade = () => {
+      // wait for upgrade to finish since we can't send packets while pausing a transport
+      this.once("upgrade", cleanupAndClose);
+      this.once("upgradeError", cleanupAndClose);
+    };
 
     if ("opening" === this.readyState || "open" === this.readyState) {
       this.readyState = "closing";
 
       if (this.writeBuffer.length) {
-        this.once("drain", function() {
+        this.once("drain", () => {
           if (this.upgrading) {
             waitForUpgrade();
           } else {
@@ -577,24 +579,6 @@ class Socket extends Emitter {
       }
     }
 
-    function close() {
-      self.onClose("forced close");
-      debug("socket closing - telling transport to close");
-      self.transport.close();
-    }
-
-    function cleanupAndClose() {
-      self.removeListener("upgrade", cleanupAndClose);
-      self.removeListener("upgradeError", cleanupAndClose);
-      close();
-    }
-
-    function waitForUpgrade() {
-      // wait for upgrade to finish since we can't send packets while pausing a transport
-      self.once("upgrade", cleanupAndClose);
-      self.once("upgradeError", cleanupAndClose);
-    }
-
     return this;
   }
 
@@ -622,7 +606,6 @@ class Socket extends Emitter {
       "closing" === this.readyState
     ) {
       debug('socket close with reason: "%s"', reason);
-      const self = this;
 
       // clear timers
       clearTimeout(this.pingIntervalTimer);
@@ -652,8 +635,8 @@ class Socket extends Emitter {
 
       // clean buffers after, so users can still
       // grab the buffers on `close` event
-      self.writeBuffer = [];
-      self.prevBufferLen = 0;
+      this.writeBuffer = [];
+      this.prevBufferLen = 0;
     }
   }
 

lib/transports/polling-jsonp.js

@@ -33,10 +33,7 @@ class JSONPPolling extends Polling {
     this.index = callbacks.length;
 
     // add callback to jsonp global
-    const self = this;
-    callbacks.push(function(msg) {
-      self.onData(msg);
-    });
+    callbacks.push(this.onData.bind(this));
 
     // append to query string
     this.query.j = this.index;
@@ -77,7 +74,6 @@ class JSONPPolling extends Polling {
    * @api private
    */
   doPoll() {
-    const self = this;
     const script = document.createElement("script");
 
     if (this.script) {
@@ -87,8 +83,8 @@ class JSONPPolling extends Polling {
 
     script.async = true;
     script.src = this.uri();
-    script.onerror = function(e) {
-      self.onError("jsonp poll error", e);
+    script.onerror = e => {
+      this.onError("jsonp poll error", e);
     };
 
     const insertAt = document.getElementsByTagName("script")[0];
@@ -119,7 +115,6 @@ class JSONPPolling extends Polling {
    * @api private
    */
   doWrite(data, fn) {
-    const self = this;
     let iframe;
 
     if (!this.form) {
@@ -149,30 +144,30 @@ class JSONPPolling extends Polling {
       fn();
     }
 
-    function initIframe() {
-      if (self.iframe) {
+    const initIframe = () => {
+      if (this.iframe) {
         try {
-          self.form.removeChild(self.iframe);
+          this.form.removeChild(this.iframe);
         } catch (e) {
-          self.onError("jsonp polling iframe removal error", e);
+          this.onError("jsonp polling iframe removal error", e);
         }
       }
 
       try {
         // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
-        const html = '<iframe src="javascript:0" name="' + self.iframeId + '">';
+        const html = '<iframe src="javascript:0" name="' + this.iframeId + '">';
         iframe = document.createElement(html);
       } catch (e) {
         iframe = document.createElement("iframe");
-        iframe.name = self.iframeId;
+        iframe.name = this.iframeId;
         iframe.src = "javascript:0";
       }
 
-      iframe.id = self.iframeId;
+      iframe.id = this.iframeId;
 
-      self.form.appendChild(iframe);
-      self.iframe = iframe;
-    }
+      this.form.appendChild(iframe);
+      this.iframe = iframe;
+    };
 
     initIframe();
 
@@ -187,7 +182,7 @@ class JSONPPolling extends Polling {
 
     if (this.iframe.attachEvent) {
       this.iframe.onreadystatechange = function() {
-        if (self.iframe.readyState === "complete") {
+        if (this.iframe.readyState === "complete") {
           complete();
         }
       };

lib/transports/polling-xhr.js

@@ -74,10 +74,9 @@ class XHR extends Polling {
       method: "POST",
       data: data
     });
-    const self = this;
     req.on("success", fn);
-    req.on("error", function(err) {
-      self.onError("xhr post error", err);
+    req.on("error", err => {
+      this.onError("xhr post error", err);
     });
   }
 
@@ -89,12 +88,9 @@ class XHR extends Polling {
   doPoll() {
     debug("xhr poll");
     const req = this.request();
-    const self = this;
-    req.on("data", function(data) {
-      self.onData(data);
-    });
-    req.on("error", function(err) {
-      self.onError("xhr poll error", err);
+    req.on("data", this.onData.bind(this));
+    req.on("error", err => {
+      this.onError("xhr poll error", err);
     });
     this.pollXhr = req;
   }
@@ -142,7 +138,6 @@ class Request extends Emitter {
     opts.xscheme = !!this.opts.xs;
 
     const xhr = (this.xhr = new XMLHttpRequest(opts));
-    const self = this;
 
     try {
       debug("xhr open %s: %s", this.method, this.uri);
@@ -178,22 +173,22 @@ class Request extends Emitter {
       }
 
       if (this.hasXDR()) {
-        xhr.onload = function() {
-          self.onLoad();
+        xhr.onload = () => {
+          this.onLoad();
         };
-        xhr.onerror = function() {
-          self.onError(xhr.responseText);
+        xhr.onerror = () => {
+          this.onError(xhr.responseText);
         };
       } else {
-        xhr.onreadystatechange = function() {
+        xhr.onreadystatechange = () => {
           if (4 !== xhr.readyState) return;
           if (200 === xhr.status || 1223 === xhr.status) {
-            self.onLoad();
+            this.onLoad();
           } else {
             // make sure the `error` event handler that's user-set
             // does not throw in the same tick and gets caught here
-            setTimeout(function() {
-              self.onError(typeof xhr.status === "number" ? xhr.status : 0);
+            setTimeout(() => {
+              this.onError(typeof xhr.status === "number" ? xhr.status : 0);
             }, 0);
           }
         };
@@ -205,8 +200,8 @@ class Request extends Emitter {
       // Need to defer since .create() is called directly from the constructor
       // and thus the 'error' event can only be only bound *after* this exception
       // occurs.  Therefore, also, we cannot throw here at all.
-      setTimeout(function() {
-        self.onError(e);
+      setTimeout(() => {
+        this.onError(e);
       }, 0);
       return;
     }