Merge branch 'larsnystrom/master'

Author: taylorotwell

src/channel/channel.ts

@@ -29,13 +29,13 @@ export abstract class Channel {
     /**
      * Stop listening to an event on the channel instance.
      */
-    abstract stopListening(event: string): Channel;
+    abstract stopListening(event: string, callback?: Function): Channel;
 
     /**
      * Stop listening for a whisper event on the channel instance.
      */
-    stopListeningForWhisper(event: string): Channel {
-        return this.stopListening('.client-' + event);
+    stopListeningForWhisper(event: string, callback?: Function): Channel {
+        return this.stopListening('.client-' + event, callback);
     }
 
     /**

src/channel/null-channel.ts

@@ -28,7 +28,7 @@ export class NullChannel extends Channel {
     /**
      * Stop listening for an event on the channel instance.
      */
-    stopListening(event: string): NullChannel {
+    stopListening(event: string, callback?: Function): NullChannel {
         return this;
     }
 

src/channel/pusher-channel.ts

@@ -70,8 +70,12 @@ export class PusherChannel extends Channel {
     /**
      * Stop listening for an event on the channel instance.
      */
-    stopListening(event: string): PusherChannel {
-        this.subscription.unbind(this.eventFormatter.format(event));
+    stopListening(event: string, callback?: Function): PusherChannel {
+        if (callback) {
+            this.subscription.unbind(this.eventFormatter.format(event), callback);
+        } else {
+            this.subscription.unbind(this.eventFormatter.format(event));
+        }
 
         return this;
     }

src/channel/socketio-channel.ts

@@ -26,10 +26,15 @@ export class SocketIoChannel extends Channel {
     eventFormatter: EventFormatter;
 
     /**
-     * The event callbacks applied to the channel.
+     * The event callbacks applied to the socket.
      */
     events: any = {};
 
+    /**
+     * User supplied callbacks for events on this channel.
+     */
+    private listeners: any = {};
+
     /**
      * Create a new class instance.
      */
@@ -42,7 +47,6 @@ export class SocketIoChannel extends Channel {
         this.eventFormatter = new EventFormatter(this.options.namespace);
 
         this.subscribe();
-        this.configureReconnector();
     }
 
     /**
@@ -79,10 +83,8 @@ export class SocketIoChannel extends Channel {
     /**
      * Stop listening for an event on the channel instance.
      */
-    stopListening(event: string): SocketIoChannel {
-        const name = this.eventFormatter.format(event);
-        this.socket.removeListener(name);
-        delete this.events[name];
+    stopListening(event: string, callback?: Function): SocketIoChannel {
+        this.unbindEvent(this.eventFormatter.format(event), callback);
 
         return this;
     }
@@ -108,47 +110,51 @@ export class SocketIoChannel extends Channel {
     /**
      * Bind the channel's socket to an event and store the callback.
      */
-    on(event: string, callback: Function): void {
-        let listener = (channel, data) => {
-            if (this.name == channel) {
-                callback(data);
-            }
-        };
+    on(event: string, callback: Function): SocketIoChannel {
+        this.listeners[event] = this.listeners[event] || [];
 
-        this.socket.on(event, listener);
-        this.bind(event, listener);
-    }
+        if (! this.events[event]) {
+            this.events[event] = (channel, data) => {
+                if (this.name === channel && this.listeners[event]) {
+                    this.listeners[event].forEach((cb) => cb(data));
+                }
+            };
 
-    /**
-     * Attach a 'reconnect' listener and bind the event.
-     */
-    configureReconnector(): void {
-        const listener = () => {
-            this.subscribe();
-        };
+            this.socket.on(event, this.events[event]);
+        }
 
-        this.socket.on('reconnect', listener);
-        this.bind('reconnect', listener);
-    }
+        this.listeners[event].push(callback);
 
-    /**
-     * Bind the channel's socket to an event and store the callback.
-     */
-    bind(event: string, callback: Function): void {
-        this.events[event] = this.events[event] || [];
-        this.events[event].push(callback);
+        return this;
     }
 
     /**
      * Unbind the channel's socket from all stored event callbacks.
      */
     unbind(): void {
         Object.keys(this.events).forEach((event) => {
-            this.events[event].forEach((callback) => {
-                this.socket.removeListener(event, callback);
-            });
-
-            delete this.events[event];
+            this.unbindEvent(event);
         });
     }
+
+    /**
+     * Unbind the listeners for the given event.
+     */
+    protected unbindEvent(event: string, callback?: Function): void {
+        this.listeners[event] = this.listeners[event] || [];
+
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+        }
+
+        if (!callback || this.listeners[event].length === 0) {
+            if (this.events[event]) {
+                this.socket.removeListener(event, this.events[event]);
+
+                delete this.events[event];
+            }
+
+            delete this.listeners[event];
+        }
+    }
 }

src/connector/socketio-connector.ts

@@ -13,7 +13,7 @@ export class SocketIoConnector extends Connector {
     /**
      * All of the subscribed channel names.
      */
-    channels: any = {};
+    channels: { [name: string]: SocketIoChannel } = {};
 
     /**
      * Create a fresh Socket.io connection.
@@ -23,6 +23,12 @@ export class SocketIoConnector extends Connector {
 
         this.socket = io(this.options.host, this.options);
 
+        this.socket.on('reconnect', () => {
+            Object.values(this.channels).forEach((channel) => {
+                channel.subscribe();
+            });
+        });
+
         return this.socket;
     }
 
@@ -67,7 +73,7 @@ export class SocketIoConnector extends Connector {
             this.channels['private-' + name] = new SocketIoPrivateChannel(this.socket, 'private-' + name, this.options);
         }
 
-        return this.channels['private-' + name];
+        return this.channels['private-' + name] as SocketIoPrivateChannel;
     }
 
     /**
@@ -82,7 +88,7 @@ export class SocketIoConnector extends Connector {
             );
         }
 
-        return this.channels['presence-' + name];
+        return this.channels['presence-' + name] as SocketIoPresenceChannel;
     }
 
     /**

tests/channel/socketio-channel.test.ts

@@ -0,0 +1,83 @@
+import { SocketIoChannel } from '../../src/channel';
+
+describe('SocketIoChannel', () => {
+    let channel;
+    let socket;
+
+    beforeEach(() => {
+        const channelName = 'some.channel';
+        let listeners = [];
+        socket = {
+            emit: (event, data) => listeners.filter(([e]) => e === event).forEach(([, fn]) => fn(channelName, data)),
+            on: (event, fn) => listeners.push([event, fn]),
+            removeListener: (event, fn) => {
+                listeners = listeners.filter(([e, f]) => (!fn ? e !== event : e !== event || f !== fn));
+            },
+        };
+
+        channel = new SocketIoChannel(socket, channelName, {
+            namespace: false,
+        });
+    });
+
+    test('triggers all listeners for an event', () => {
+        const l1 = jest.fn();
+        const l2 = jest.fn();
+        const l3 = jest.fn();
+        channel.listen('MyEvent', l1);
+        channel.listen('MyEvent', l2);
+        channel.listen('MyOtherEvent', l3);
+
+        socket.emit('MyEvent', {});
+
+        expect(l1).toBeCalled();
+        expect(l2).toBeCalled();
+        expect(l3).not.toBeCalled();
+
+        socket.emit('MyOtherEvent', {});
+
+        expect(l3).toBeCalled();
+    });
+
+    test('can remove a listener for an event', () => {
+        const l1 = jest.fn();
+        const l2 = jest.fn();
+        const l3 = jest.fn();
+        channel.listen('MyEvent', l1);
+        channel.listen('MyEvent', l2);
+        channel.listen('MyOtherEvent', l3);
+
+        channel.stopListening('MyEvent', l1);
+
+        socket.emit('MyEvent', {});
+
+        expect(l1).not.toBeCalled();
+        expect(l2).toBeCalled();
+        expect(l3).not.toBeCalled();
+
+        socket.emit('MyOtherEvent', {});
+
+        expect(l3).toBeCalled();
+    });
+
+    test('can remove all listeners for an event', () => {
+        const l1 = jest.fn();
+        const l2 = jest.fn();
+        const l3 = jest.fn();
+        channel.listen('MyEvent', l1);
+        channel.listen('MyEvent', l2);
+        channel.listen('MyOtherEvent', l3);
+
+        channel.stopListening('MyEvent');
+
+        socket.emit('MyEvent', {});
+
+        expect(l1).not.toBeCalled();
+        expect(l2).not.toBeCalled();
+        expect(l3).not.toBeCalled();
+
+        socket.emit('MyOtherEvent', {});
+
+        expect(l3).toBeCalled();
+    });
+});