init

www/bower_components/angular-socket-io/.bower.json

@@ -0,0 +1,21 @@
+{
+  "name": "angular-socket-io",
+  "version": "0.7.0",
+  "main": "socket.js",
+  "dependencies": {
+    "angular": "^1.2.6"
+  },
+  "devDependencies": {
+    "angular-mocks": "^1.2.6"
+  },
+  "homepage": "https://github.com/btford/angular-socket-io",
+  "_release": "0.7.0",
+  "_resolution": {
+    "type": "version",
+    "tag": "v0.7.0",
+    "commit": "0864970501e7f5ce82b1182e29ed1b63e80cf5cc"
+  },
+  "_source": "https://github.com/btford/angular-socket-io.git",
+  "_target": "^0.7.0",
+  "_originalSource": "angular-socket-io"
+}

www/bower_components/angular-socket-io/.gitignore

@@ -0,0 +1,3 @@
+coverage/
+node_modules/
+bower_components/

www/bower_components/angular-socket-io/.travis.yml

@@ -0,0 +1,10 @@
+language: node_js
+node_js:
+  - 0.10
+env:
+  - VERSION=1.2
+  - VERSION=1.3
+before_script:
+  - ./npm-install.sh
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start

www/bower_components/angular-socket-io/README.md

@@ -0,0 +1,250 @@
+# angular-socket-io [![Build Status](https://travis-ci.org/btford/angular-socket-io.svg)](https://travis-ci.org/btford/angular-socket-io)
+
+Bower Component for using AngularJS with [Socket.IO](http://socket.io/),
+based on [this](http://briantford.com/blog/angular-socket-io.html).
+
+
+## Install
+
+1. `bower install angular-socket-io` or [download the zip](https://github.com/btford/angular-socket-io/archive/master.zip).
+2. Make sure the Socket.IO client lib is loaded. It's often served at `/socket.io/socket.io.js`.
+3. Include the `socket.js` script provided by this component into your app.
+4. Add `btford.socket-io` as a module dependency to your app.
+
+
+## Usage
+
+This module exposes a `socketFactory`, which is an API for instantiating
+sockets that are integrated with Angular's digest cycle.
+
+
+### Making a Socket Instance
+
+```javascript
+// in the top-level module of the app
+angular.module('myApp', [
+  'btford.socket-io',
+  'myApp.MyCtrl'
+]).
+factory('mySocket', function (socketFactory) {
+  return socketFactory();
+});
+```
+
+With that, you can inject your `mySocket` service into controllers and
+other serivices within your application!
+
+### Using Your Socket Instance
+
+Building on the example above:
+
+```javascript
+// in the top-level module of the app
+angular.module('myApp', [
+  'btford.socket-io',
+  'myApp.MyCtrl'
+]).
+factory('mySocket', function (socketFactory) {
+  return socketFactory();
+}).
+controller('MyCtrl', function (mySocket) {
+  // ...
+});
+```
+
+
+## API
+
+For the most part, this component works exactly like you would expect.
+The only API addition is `socket.forward`, which makes it easier to add/remove listeners in a way that works with [AngularJS's scope](http://docs.angularjs.org/api/ng.$rootScope.Scope).
+
+### `socket.on` / `socket.addListener`
+Takes an event name and callback.
+Works just like the method of the same name from Socket.IO.
+
+### `socket.removeListener`
+Takes an event name and callback.
+Works just like the method of the same name from Socket.IO.
+
+### `socket.removeAllListeners`
+Takes an event name.
+Works just like the method of the same name from Socket.IO.
+
+### `socket.emit`
+Sends a message to the server.
+Optionally takes a callback.
+
+Works just like the method of the same name from Socket.IO.
+
+### `socket.forward`
+
+`socket.forward` allows you to forward the events received by Socket.IO's socket to AngularJS's event system.
+You can then listen to the event with `$scope.$on`.
+By default, socket-forwarded events are namespaced with `socket:`.
+
+The first argument is a string or array of strings listing the event names to be forwarded.
+The second argument is optional, and is the scope on which the events are to be broadcast.
+If an argument is not provided, it defaults to `$rootScope`.
+As a reminder, broadcasted events are propagated down to descendant scopes.
+
+#### Examples
+
+An easy way to make socket error events available across your app:
+
+```javascript
+// in the top-level module of the app
+angular.module('myApp', [
+  'btford.socket-io',
+  'myApp.MyCtrl'
+]).
+factory('mySocket', function (socketFactory) {
+  var mySocket = socketFactory();
+  mySocket.forward('error');
+  return mySocket;
+});
+
+// in one of your controllers
+angular.module('myApp.MyCtrl', []).
+  controller('MyCtrl', function ($scope) {
+    $scope.$on('socket:error', function (ev, data) {
+
+    });
+  });
+```
+
+Avoid duplicating event handlers when a user navigates back and forth between routes:
+
+```javascript
+angular.module('myMod', ['btford.socket-io']).
+  controller('MyCtrl', function ($scope, socket) {
+    socket.forward('someEvent', $scope);
+    $scope.$on('socket:someEvent', function (ev, data) {
+      $scope.theData = data;
+    });
+  });
+```
+
+
+### `socketFactory({ ioSocket: }}`
+
+This option allows you to provide the `socket` service with a `Socket.IO socket` object to be used internally.
+This is useful if you want to connect on a different path, or need to hold a reference to the `Socket.IO socket` object for use elsewhere.
+
+```javascript
+angular.module('myApp', [
+  'btford.socket-io'
+]).
+factory('mySocket', function (socketFactory) {
+  var myIoSocket = io.connect('/some/path');
+
+  mySocket = socketFactory({
+    ioSocket: myIoSocket
+  });
+
+  return mySocket;
+});
+```
+
+### `socketFactory({ scope: })`
+
+This option allows you to set the scope on which `$broadcast` is forwarded to when using the `forward` method.
+It defaults to `$rootScope`.
+
+
+### `socketFactory({ prefix: })`
+
+The default prefix is `socket:`.
+
+
+#### Example
+
+To remove the prefix:
+
+```javascript
+angular.module('myApp', [
+  'btford.socket-io'
+]).
+config(function (socketProvider) {
+  socketProvider.prefix('');
+});
+```
+
+
+
+## Migrating from 0.2 to 0.3
+
+`angular-socket-io` version `0.3` changes X to make fewer assumptions
+about the lifecycle of the socket. Previously, the assumption was that your
+application has a single socket created at config time. While this holds
+for most apps I've seen, there's no reason you shouldn't be able to
+lazily create sockets, or have multiple connections.
+
+In `0.2`, `angular-socket-io` exposed a `socket` service. In `0.3`, it
+instead exposes a `socketFactory` service which returns socket instances.
+Thus, getting the old API is as simple as making your own `socket` service
+with `socketFactory`. The examples below demonstrate how to do this.
+
+### Simple Example
+
+In most cases, adding the following to your app should suffice:
+
+```javascript
+// ...
+factory('socket', function (socketFactory) {
+  return socketFactory();
+});
+// ...
+```
+
+### Example with Configuration
+
+Before:
+
+```javascript
+angular.module('myApp', [
+  'btford.socket-io'
+]).
+config(function (socketProvider) {
+  socketProvider.prefix('foo~');
+  socketProvider.ioSocket(io.connect('/some/path'));
+}).
+controller('MyCtrl', function (socket) {
+  socket.on('foo~bar', function () {
+    $scope.bar = true;
+  });
+});
+```
+
+After:
+
+```javascript
+angular.module('myApp', [
+  'btford.socket-io'
+]).
+factory('socket', function (socketFactory) {
+  return socketFactory({
+    prefix: 'foo~',
+    ioSocket: io.connect('/some/path')
+  });
+}).
+controller('MyCtrl', function (socket) {
+  socket.on('foo~bar', function () {
+    $scope.bar = true;
+  });
+});
+```
+
+
+## FAQ
+
+[Closed issues labelled `FAQ`](https://github.com/btford/angular-socket-io/issues?labels=faq&page=1&state=closed) might have the answer to your question.
+
+
+## See Also
+
+* [ngSocket](https://github.com/jeffbcross/ngSocket)
+* [angular-socket.io-mock](https://github.com/nullivex/angular-socket.io-mock)
+
+
+## License
+MIT

www/bower_components/angular-socket-io/bower.json

@@ -0,0 +1,11 @@
+{
+  "name": "angular-socket-io",
+  "version": "0.7.0",
+  "main": "socket.js",
+  "dependencies": {
+    "angular": "^1.2.6"
+  },
+  "devDependencies": {
+    "angular-mocks": "^1.2.6"
+  }
+}

www/bower_components/angular-socket-io/gulpfile.js

@@ -0,0 +1,15 @@
+var gulp = require('gulp'),
+  uglify = require('gulp-uglify'),
+  rename = require('gulp-rename');
+
+gulp.task('scripts', function() {
+  return gulp.src('socket.js')
+    .pipe(rename('socket.min.js'))
+    .pipe(uglify({
+      preserveComments: 'some',
+      outSourceMap: true
+    }))
+    .pipe(gulp.dest('.'));
+});
+
+gulp.task('default', ['scripts']);

www/bower_components/angular-socket-io/karma.conf.js

@@ -0,0 +1,28 @@
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    files: [
+      'mock/socket-io.js',
+      'node_modules/angular/angular.js',
+      'node_modules/angular-mocks/angular-mocks.js',
+      'socket.js',
+      '*.spec.js'
+    ],
+
+    reporters: ['progress'],
+
+    port: 9876,
+    colors: true,
+
+    logLevel: config.LOG_INFO,
+
+    browsers: ['Chrome'],
+    frameworks: ['jasmine'],
+
+    captureTimeout: 60000,
+
+    autoWatch: true,
+    singleRun: false
+  });
+};

www/bower_components/angular-socket-io/mock/socket-io.js

@@ -0,0 +1,49 @@
+var io = {
+  connect: createMockSocketObject
+};
+
+function createMockSocketObject () {
+
+  var socket = {
+    on: function (ev, fn) {
+      (this._listeners[ev] = this._listeners[ev] || []).push(fn);
+    },
+    once: function (ev, fn) {
+      (this._listeners[ev] = this._listeners[ev] || []).push(fn);
+      fn._once = true;
+    },
+    emit: function (ev, data) {
+      if (this._listeners[ev]) {
+        var args = arguments;
+        this._listeners[ev].forEach(function (listener) {
+          if (listener._once) {
+            this.removeListener(ev, listener);
+          }
+          listener.apply(null, Array.prototype.slice.call(args, 1));
+        }.bind(this));
+      }
+    },
+    _listeners: {},
+    removeListener: function (ev, fn) {
+      if (fn) {
+        var index = this._listeners[ev].indexOf(fn);
+        if (index > -1) {
+          this._listeners[ev].splice(index, 1);
+        }
+      } else {
+        delete this._listeners[ev];
+      }
+    },
+    removeAllListeners: function (ev) {
+      if (ev) {
+        delete this._listeners[ev];
+      } else {
+        this._listeners = {};
+      }
+    },
+    disconnect: function () {},
+    connect: function () {}
+  };
+
+  return socket;
+}

www/bower_components/angular-socket-io/npm-install.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+npm install angular@$VERSION angular-mocks@$VERSION

www/bower_components/angular-socket-io/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "angular-socket-io",
+  "version": "0.7.0",
+  "main": "socket.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "./node_modules/.bin/karma start --browsers Firefox --single-run"
+  },
+  "author": "Brian Ford",
+  "license": "MIT",
+  "devDependencies": {
+    "angular": "^1.3.5",
+    "angular-mocks": "^1.3.5",
+    "gulp": "^3.8.10",
+    "gulp-rename": "~1.2.0",
+    "gulp-uglify": "~0.2.1",
+    "karma": "~0.10.2",
+    "karma-firefox-launcher": "~0.1.0",
+    "karma-jasmine": "~0.1.3"
+  }
+}

www/bower_components/angular-socket-io/socket.js

@@ -0,0 +1,103 @@
+/*
+ * @license
+ * angular-socket-io v0.7.0
+ * (c) 2014 Brian Ford http://briantford.com
+ * License: MIT
+ */
+
+angular.module('btford.socket-io', []).
+  provider('socketFactory', function () {
+
+    'use strict';
+
+    // when forwarding events, prefix the event name
+    var defaultPrefix = 'socket:',
+      ioSocket;
+
+    // expose to provider
+    this.$get = ['$rootScope', '$timeout', function ($rootScope, $timeout) {
+
+      var asyncAngularify = function (socket, callback) {
+        return callback ? function () {
+          var args = arguments;
+          $timeout(function () {
+            callback.apply(socket, args);
+          }, 0);
+        } : angular.noop;
+      };
+
+      return function socketFactory (options) {
+        options = options || {};
+        var socket = options.ioSocket || io.connect();
+        var prefix = options.prefix === undefined ? defaultPrefix : options.prefix ;
+        var defaultScope = options.scope || $rootScope;
+
+        var addListener = function (eventName, callback) {
+          socket.on(eventName, callback.__ng = asyncAngularify(socket, callback));
+        };
+
+        var addOnceListener = function (eventName, callback) {
+          socket.once(eventName, callback.__ng = asyncAngularify(socket, callback));
+        };
+
+        var wrappedSocket = {
+          on: addListener,
+          addListener: addListener,
+          once: addOnceListener,
+
+          emit: function (eventName, data, callback) {
+            var lastIndex = arguments.length - 1;
+            var callback = arguments[lastIndex];
+            if(typeof callback == 'function') {
+              callback = asyncAngularify(socket, callback);
+              arguments[lastIndex] = callback;
+            }
+            return socket.emit.apply(socket, arguments);
+          },
+
+          removeListener: function (ev, fn) {
+            if (fn && fn.__ng) {
+              arguments[1] = fn.__ng;
+            }
+            return socket.removeListener.apply(socket, arguments);
+          },
+
+          removeAllListeners: function() {
+            return socket.removeAllListeners.apply(socket, arguments);
+          },
+
+          disconnect: function (close) {
+            return socket.disconnect(close);
+          },
+
+          connect: function() {
+            return socket.connect();
+          },
+
+          // when socket.on('someEvent', fn (data) { ... }),
+          // call scope.$broadcast('someEvent', data)
+          forward: function (events, scope) {
+            if (events instanceof Array === false) {
+              events = [events];
+            }
+            if (!scope) {
+              scope = defaultScope;
+            }
+            events.forEach(function (eventName) {
+              var prefixedEvent = prefix + eventName;
+              var forwardBroadcast = asyncAngularify(socket, function () {
+                Array.prototype.unshift.call(arguments, prefixedEvent);
+                scope.$broadcast.apply(scope, arguments);
+              });
+              scope.$on('$destroy', function () {
+                socket.removeListener(eventName, forwardBroadcast);
+              });
+              socket.on(eventName, forwardBroadcast);
+            });
+          }
+        };
+
+        return wrappedSocket;
+      };
+    }];
+  });

www/bower_components/angular-socket-io/socket.min.js

@@ -0,0 +1,8 @@
+/*
+ * @license
+ * angular-socket-io v0.7.0
+ * (c) 2014 Brian Ford http://briantford.com
+ * License: MIT
+ */
+angular.module("btford.socket-io",[]).provider("socketFactory",function(){"use strict";var n="socket:";this.$get=["$rootScope","$timeout",function(t,e){var r=function(n,t){return t?function(){var r=arguments;e(function(){t.apply(n,r)},0)}:angular.noop};return function(e){e=e||{};var o=e.ioSocket||io.connect(),c=void 0===e.prefix?n:e.prefix,u=e.scope||t,i=function(n,t){o.on(n,t.__ng=r(o,t))},a=function(n,t){o.once(n,t.__ng=r(o,t))},s={on:i,addListener:i,once:a,emit:function(n,t,e){var c=arguments.length-1,e=arguments[c];return"function"==typeof e&&(e=r(o,e),arguments[c]=e),o.emit.apply(o,arguments)},removeListener:function(n,t){return t&&t.__ng&&(arguments[1]=t.__ng),o.removeListener.apply(o,arguments)},removeAllListeners:function(){return o.removeAllListeners.apply(o,arguments)},disconnect:function(n){return o.disconnect(n)},connect:function(){return o.connect()},forward:function(n,t){n instanceof Array==!1&&(n=[n]),t||(t=u),n.forEach(function(n){var e=c+n,u=r(o,function(){Array.prototype.unshift.call(arguments,e),t.$broadcast.apply(t,arguments)});t.$on("$destroy",function(){o.removeListener(n,u)}),o.on(n,u)})}};return s}}]});
+//# sourceMappingURL=socket.min.js.map

www/bower_components/angular-socket-io/socket.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.min.js.map","sources":["socket.min.js"],"names":["angular","module","provider","defaultPrefix","this","$get","$rootScope","$timeout","asyncAngularify","socket","callback","args","arguments","apply","noop","options","ioSocket","io","connect","prefix","undefined","defaultScope","scope","addListener","eventName","on","__ng","addOnceListener","once","wrappedSocket","emit","data","lastIndex","length","removeListener","ev","fn","removeAllListeners","disconnect","close","forward","events","Array","forEach","prefixedEvent","forwardBroadcast","prototype","unshift","call","$broadcast","$on"],"mappings":";;;;;;AAOAA,QAAQC,OAAO,uBACbC,SAAS,gBAAiB,WAExB,YAGA,IAAIC,GAAgB,SAIpBC,MAAKC,MAAQ,aAAc,WAAY,SAAUC,EAAYC,GAE3D,GAAIC,GAAkB,SAAUC,EAAQC,GACtC,MAAOA,GAAW,WAChB,GAAIC,GAAOC,SACXL,GAAS,WACPG,EAASG,MAAMJ,EAAQE,IACtB,IACDX,QAAQc,KAGd,OAAO,UAAwBC,GAC7BA,EAAUA,KACV,IAAIN,GAASM,EAAQC,UAAYC,GAAGC,UAChCC,EAA4BC,SAAnBL,EAAQI,OAAuBhB,EAAgBY,EAAQI,OAChEE,EAAeN,EAAQO,OAAShB,EAEhCiB,EAAc,SAAUC,EAAWd,GACrCD,EAAOgB,GAAGD,EAAWd,EAASgB,KAAOlB,EAAgBC,EAAQC,KAG3DiB,EAAkB,SAAUH,EAAWd,GACzCD,EAAOmB,KAAKJ,EAAWd,EAASgB,KAAOlB,EAAgBC,EAAQC,KAG7DmB,GACFJ,GAAIF,EACJA,YAAaA,EACbK,KAAMD,EAENG,KAAM,SAAUN,EAAWO,EAAMrB,GAC/B,GAAIsB,GAAYpB,UAAUqB,OAAS,EAC/BvB,EAAWE,UAAUoB,EAKzB,OAJsB,kBAAZtB,KACRA,EAAWF,EAAgBC,EAAQC,GACnCE,UAAUoB,GAAatB,GAElBD,EAAOqB,KAAKjB,MAAMJ,EAAQG,YAGnCsB,eAAgB,SAAUC,EAAIC,GAI5B,MAHIA,IAAMA,EAAGV,OACXd,UAAU,GAAKwB,EAAGV,MAEbjB,EAAOyB,eAAerB,MAAMJ,EAAQG,YAG7CyB,mBAAoB,WAClB,MAAO5B,GAAO4B,mBAAmBxB,MAAMJ,EAAQG,YAGjD0B,WAAY,SAAUC,GACpB,MAAO9B,GAAO6B,WAAWC,IAG3BrB,QAAS,WACP,MAAOT,GAAOS,WAKhBsB,QAAS,SAAUC,EAAQnB,GACrBmB,YAAkBC,SAAU,IAC9BD,GAAUA,IAEPnB,IACHA,EAAQD,GAEVoB,EAAOE,QAAQ,SAAUnB,GACvB,GAAIoB,GAAgBzB,EAASK,EACzBqB,EAAmBrC,EAAgBC,EAAQ,WAC7CiC,MAAMI,UAAUC,QAAQC,KAAKpC,UAAWgC,GACxCtB,EAAM2B,WAAWpC,MAAMS,EAAOV,YAEhCU,GAAM4B,IAAI,WAAY,WACpBzC,EAAOyB,eAAeV,EAAWqB,KAEnCpC,EAAOgB,GAAGD,EAAWqB,MAK3B,OAAOhB"}

www/bower_components/angular-socket-io/socket.spec.js

@@ -0,0 +1,263 @@
+/*
+ * angular-socket-io v0.4.1
+ * (c) 2014 Brian Ford http://briantford.com
+ * License: MIT
+ */
+
+'use strict';
+
+
+describe('socketFactory', function () {
+
+  beforeEach(module('btford.socket-io'));
+
+  var socket,
+      scope,
+      $timeout,
+      $browser,
+      mockIoSocket,
+      spy;
+
+  beforeEach(inject(function (socketFactory, _$browser_, $rootScope, _$timeout_) {
+    $browser = _$browser_;
+    $timeout = _$timeout_;
+    scope = $rootScope.$new();
+    spy = jasmine.createSpy('emitSpy');
+    mockIoSocket = io.connect();
+    socket = socketFactory({
+      ioSocket: mockIoSocket,
+      scope: scope
+    });
+  }));
+
+
+  describe('#on', function () {
+
+    it('should apply asynchronously', function () {
+      socket.on('event', spy);
+
+      mockIoSocket.emit('event');
+
+      expect(spy).not.toHaveBeenCalled();
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
+  });
+
+
+  describe('#disconnect', function () {
+
+    it('should call the underlying socket.disconnect', function () {
+      mockIoSocket.disconnect = spy;
+      socket.disconnect();
+      expect(spy).toHaveBeenCalled();
+    });
+
+  });
+
+  describe('#connect', function () {
+
+    it('should call the underlying socket.connect', function () {
+      mockIoSocket.connect = spy;
+      socket.connect();
+      expect(spy).toHaveBeenCalled();
+    });
+
+  });
+
+
+  describe('#once', function () {
+
+    it('should apply asynchronously', function () {
+      socket.once('event', spy);
+
+      mockIoSocket.emit('event');
+
+      expect(spy).not.toHaveBeenCalled();
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should only run once', function () {
+      var counter = 0;
+      socket.once('event', function () {
+        counter += 1;
+      });
+
+      mockIoSocket.emit('event');
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(counter).toBe(1);
+    });
+
+  });
+
+
+  describe('#emit', function () {
+
+    it('should call the delegate socket\'s emit', function () {
+      spyOn(mockIoSocket, 'emit');
+
+      socket.emit('event', {foo: 'bar'});
+
+      expect(mockIoSocket.emit).toHaveBeenCalled();
+    });
+
+    it('should allow multiple data arguments', function () {
+      spyOn(mockIoSocket, 'emit');
+      socket.emit('event', 'x', 'y');
+      expect(mockIoSocket.emit).toHaveBeenCalledWith('event', 'x', 'y');
+    });
+
+    it('should wrap the callback with multiple data arguments', function () {
+      spyOn(mockIoSocket, 'emit');
+      socket.emit('event', 'x', 'y', spy);
+      expect(mockIoSocket.emit.mostRecentCall.args[3]).toNotBe(spy);
+
+      mockIoSocket.emit.mostRecentCall.args[3]();
+      expect(spy).not.toHaveBeenCalled();
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
+  });
+
+
+  describe('#removeListener', function () {
+
+    it('should not call after removing an event', function () {
+      socket.on('event', spy);
+      socket.removeListener('event', spy);
+
+      mockIoSocket.emit('event');
+
+      expect($browser.deferredFns.length).toBe(0);
+    });
+
+  });
+
+
+  describe('#removeAllListeners', function () {
+
+    it('should not call after removing listeners for an event', function () {
+      socket.on('event', spy);
+      socket.removeAllListeners('event');
+
+      mockIoSocket.emit('event');
+
+      expect($browser.deferredFns.length).toBe(0);
+    });
+
+    it('should not call after removing all listeners', function () {
+      socket.on('event', spy);
+      socket.on('event2', spy);
+      socket.removeAllListeners();
+
+      mockIoSocket.emit('event');
+      mockIoSocket.emit('event2');
+
+      expect($browser.deferredFns.length).toBe(0);
+    });
+
+  });
+
+
+  describe('#forward', function () {
+
+    it('should forward events', function () {
+      socket.forward('event');
+
+      scope.$on('socket:event', spy);
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should forward an array of events', function () {
+      socket.forward(['e1', 'e2']);
+
+      scope.$on('socket:e1', spy);
+      scope.$on('socket:e2', spy);
+
+      mockIoSocket.emit('e1');
+      mockIoSocket.emit('e2');
+      $timeout.flush();
+      expect(spy.callCount).toBe(2);
+    });
+
+    it('should remove watchers when the scope is removed', function () {
+
+      socket.forward('event');
+      scope.$on('socket:event', spy);
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+
+      scope.$destroy();
+      spy.reset();
+      mockIoSocket.emit('event');
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('should use the specified prefix', inject(function (socketFactory) {
+      var socket = socketFactory({
+        ioSocket: mockIoSocket,
+        scope: scope,
+        prefix: 'custom:'
+      });
+
+      socket.forward('event');
+
+      scope.$on('custom:event', spy);
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    }));
+
+    it('should use an empty prefix if specified', inject(function (socketFactory) {
+      var socket = socketFactory({
+        ioSocket: mockIoSocket,
+        scope: scope,
+        prefix: ''
+      });
+
+      socket.forward('event');
+
+      scope.$on('event', spy);
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(spy).toHaveBeenCalled();
+    }));
+
+    it('should forward to the specified scope when one is provided', function () {
+      var child = scope.$new();
+      spyOn(child, '$broadcast');
+      socket.forward('event', child);
+
+      scope.$on('socket:event', spy);
+      mockIoSocket.emit('event');
+      $timeout.flush();
+
+      expect(child.$broadcast).toHaveBeenCalled();
+    });
+
+    it('should pass all arguments to scope.$on', function () {
+      socket.forward('event');
+      scope.$on('socket:event', spy);
+      mockIoSocket.emit('event', 1, 2, 3);
+      $timeout.flush();
+
+      expect(spy.calls[0].args.slice(1)).toEqual([1, 2, 3]);
+    });
+  });
+
+});