Add semicolon lint rule

.eslintrc

@@ -6,7 +6,7 @@
     "no-unexpected-multiline": 2,
     "no-unreachable": 2,
     "quotes": [2, "single"],
-    "semi": [2, "never"]
+    "semi": "error"
   },
   "env": {
     "browser": true,

lib/error.js

@@ -1,14 +1,14 @@
-var util = require('util')
+var util = require('util');
 
 function NotFound(message, options) {
-  Error.call(this)
+  Error.call(this);
-  options = options || {}
+  options = options || {};
-  this.message = message || ''
+  this.message = message || '';
-  this.location = options.location || ''
+  this.location = options.location || '';
 }
 
-util.inherits(NotFound, Error)
+util.inherits(NotFound, Error);
 
 module.exports = {
   NotFound: NotFound
-}
+};

lib/route-node.js

@@ -1,119 +1,117 @@
-'use strict'
+var NotFoundError = require('./error').NotFound;
-var NotFoundError = require('./error').NotFound
+var utils = require('./utils');
-var utils = require('./utils')
 
-var assign = utils.assign
+var assign = utils.assign;
-var isFunction = utils.isFunction
+var isFunction = utils.isFunction;
-var isRegExp = utils.isRegExp
+var isRegExp = utils.isRegExp;
-var isString = utils.isString
+var isString = utils.isString;
-var noop = utils.noop
+var noop = utils.noop;
 
 function RouteNode () {
-  this._children = Object.create(null)
+  this._children = Object.create(null);
-  this._funcs = Object.create(null)
+  this._funcs = Object.create(null);
-  this._regExs = Object.create(null)
+  this._regExs = Object.create(null);
 }
 
 assign(RouteNode.prototype, {
   handler: null,
 
   add: function add(parts, handler, context) {
-    parts = parts || []
+    parts = parts || [];
-    handler = handler || noop
+    handler = handler || noop;
-    context = context || null
+    context = context || null;
 
     if (parts.length === 0) {
-      this.handler = handler
+      this.handler = handler;
-      this.context = context
+      this.context = context;
-      return this
+      return this;
     }
-    var part = parts.shift()
+    var part = parts.shift();
-    var node = null
+    var node = null;
 
     if (isString(part)) {
-      node = this._children[part]
+      node = this._children[part];
     } else if (isRegExp(part)) {
-      this._regExs[part] = part
+      this._regExs[part] = part;
     } else if (isFunction(part)) {
-      this._funcs[part] = part
+      this._funcs[part] = part;
     }
 
     if (node == null) {
-      node = new RouteNode()
+      node = new RouteNode();
-      this._children[part] = node
+      this._children[part] = node;
     }
-    return node.add(parts, handler, context)
+    return node.add(parts, handler, context);
   },
 
   get: function get(parts, args, done) {
-    parts = parts || []
+    parts = parts || [];
-    args = args || []
+    args = args || [];
     if (parts.length === 0) {
-      return done(null, this.handler, this.context, args)
+      return done(null, this.handler, this.context, args);
     }
 
-    var part = parts.shift()
+    var part = parts.shift();
 
     // Check exact matches
     if (this._children[part]) {
-      return this._children[part].get(parts, args, done)
+      return this._children[part].get(parts, args, done);
     }
 
     // Check regex matches
-    var results = this._getRegexChild(part)
+    var results = this._getRegexChild(part);
     if (results && results.node) {
-      return results.node.get(parts, args.concat(results.args), done)
+      return results.node.get(parts, args.concat(results.args), done);
     }
 
     // Check function matches
-    results = this._getFunctionChild(part)
+    results = this._getFunctionChild(part);
     if (results && results.node) {
-      return results.node.get(parts, args.concat(results.args), done)
+      return results.node.get(parts, args.concat(results.args), done);
     }
 
-    return done(new NotFoundError('not found', {location: parts}))
+    return done(new NotFoundError('not found', {location: parts}));
   },
 
   _getRegexChild: function _getRegexChild(part) {
-    var self = this
+    var self = this;
 
     return Object.keys(this._regExs).reduce(function checkRegex(memo, key) {
       if (memo) {
-        return memo
+        return memo;
       }
-      var regex = self._regExs[key]
+      var regex = self._regExs[key];
-      var results = regex.exec(part)
+      var results = regex.exec(part);
       if (!results) {
-        return null
+        return null;
       }
 
-      var lastIndex = null
+      var lastIndex = null;
-      var args = []
+      var args = [];
       while (results && results.index !== lastIndex) {
-        args = args.concat(results[0])
+        args = args.concat(results[0]);
-        lastIndex = results.index
+        lastIndex = results.index;
-        results = regex.exec(part)
+        results = regex.exec(part);
       }
-      return {args: args, key: key, node: self._children[key]}
+      return {args: args, key: key, node: self._children[key]};
-    }, null)
+    }, null);
   },
 
   _getFunctionChild: function _getFunctionChild(part) {
-    var self = this
+    var self = this;
     return Object.keys(self._funcs).reduce(function checkFunc(memo, key) {
       if (memo) {
-        return memo
+        return memo;
       }
-      var func = self._funcs[key]
+      var func = self._funcs[key];
-      var result = func(part)
+      var result = func(part);
       if (result) {
-        return {args: [result], key: key, node: self._children[key]}
+        return {args: [result], key: key, node: self._children[key]};
       } else {
-        return null
+        return null;
       }
-    }, null)
+    }, null);
   }
+});
 
-})
+module.exports = RouteNode;
-
-module.exports = RouteNode

lib/router.js

@@ -1,46 +1,45 @@
-'use strict'
+var url = require('url');
-var url = require('url')
+var NotFoundError = require('./error').NotFound;
-var NotFoundError = require('./error').NotFound
+var RouteNode = require('./route-node');
-var RouteNode = require('./route-node')
+var utils = require('./utils');
-var utils = require('./utils')
 
-var assign = utils.assign
+var assign = utils.assign;
-var isArray = utils.isArray
+var isArray = utils.isArray;
-var isFunction = utils.isFunction
+var isFunction = utils.isFunction;
-var isString = utils.isString
+var isString = utils.isString;
-var noop = utils.noop
+var noop = utils.noop;
 
 function Router() {
-  this.routes = new RouteNode()
+  this.routes = new RouteNode();
 }
 
 assign(Router.prototype, {
   add: function add(path, handler) {
-    return this.routes.add(this._uriToParts(path), handler)
+    return this.routes.add(this._uriToParts(path), handler);
   },
 
   route: function route(path, options, done) {
     if (done == null && isFunction(options)) {
-      done = options
+      done = options;
-      options = {}
+      options = {};
     }
-    options = options || {}
+    options = options || {};
-    var routeArray = this._uriToParts(path)
+    var routeArray = this._uriToParts(path);
-    done = done || noop
+    done = done || noop;
 
     function _routeCallback(err, func, context, args) {
       if (err) {
-        return done(err)
+        return done(err);
       } else {
         if (isFunction(func)) {
-          return done(null, func.apply(context, args))
+          return done(null, func.apply(context, args));
         } else {
-          return done(new NotFoundError('not found', {location: path}))
+          return done(new NotFoundError('not found', {location: path}));
         }
       }
     }
 
-    return this.routes.get(routeArray, (options.args || []), _routeCallback)
+    return this.routes.get(routeArray, (options.args || []), _routeCallback);
   },
 
   _uriToParts: function _uriToParts(uri) {
@@ -48,25 +47,25 @@ assign(Router.prototype, {
       return url.parse(uri)
         .pathname
         .split('/')
-        .filter(function (str) { return str !== ''})
+        .filter(function (str) { return str !== ''; });
     } else if (isArray(uri)) {
-      return uri.reduce(this._uriToPartsReducer.bind(this), [])
+      return uri.reduce(this._uriToPartsReducer.bind(this), []);
     }
   },
 
   _uriToPartsReducer: function _uriToPartsReducer(memo, item) {
     if (isArray(item)) {
-      return memo.concat(item)
+      return memo.concat(item);
     } else if (isString(item)) {
-      return memo.concat(this._uriToParts(item))
+      return memo.concat(this._uriToParts(item));
     } else {
-      return memo.concat(item)
+      return memo.concat(item);
     }
   }
-})
+});
 
 Router.isNotFound = function isNotFound(err) {
-  return err instanceof NotFoundError
+  return err instanceof NotFoundError;
-}
+};
 
-module.exports = Router
+module.exports = Router;

lib/utils.js

@@ -1,39 +1,37 @@
-'use strict'
+var toString = ({}).toString;
-
+var hasOwnProp = ({}).hasOwnProperty;
-var toString = ({}).toString
-var hasOwnProp = ({}).hasOwnProperty
 
 var utils = {
   noop: function noop() {},
 
   isString: function isString(str) {
-    return typeof str === 'string'
+    return typeof str === 'string';
   },
 
   forEach: function forEach(obj, fn) {
     for (var key in obj) {
       if (hasOwnProp.call(obj, key)) {
-        fn(key, obj[key])
+        fn(key, obj[key]);
       }
     }
   },
 
   assign: function assign (dest, methods) {
     utils.forEach(methods, function (key, val) {
-      dest[key] = val
+      dest[key] = val;
-    })
+    });
   }
-}
+};
 
 function checkType(type) {
   return function _checkType(val) {
-    return toString.call(val) === '[object ' + type + ']'
+    return toString.call(val) === '[object ' + type + ']';
-  }
+  };
 }
 
 // add isRegExp, isArray, isFunction
 ['RegExp', 'Array', 'Function'].forEach(function addIsChecks(type) {
-  utils['is' + type] = checkType(type)
+  utils['is' + type] = checkType(type);
-})
+});
 
-module.exports = utils
+module.exports = utils;

package.json

@@ -4,7 +4,8 @@
   "description": "Another router library for both client and server",
   "main": "lib/router.js",
   "scripts": {
-    "test": "mocha --reporter dot && eslint lib/*.js test/*.js"
+    "lint": "eslint lib/*.js test/*.js",
+    "test": "mocha --reporter dot && npm run lint"
   },
   "repository": {
     "type": "git",

test/route-node.js

@@ -1,91 +1,90 @@
-var expect = require('expect')
+var expect = require('expect');
-var RouteNode = require('../lib/route-node')
+var RouteNode = require('../lib/route-node');
 
 module.exports = describe('RouteNode', function () {
   it('→ exists', function () {
-    expect(new RouteNode()).toBeInstanceOf(RouteNode)
+    expect(new RouteNode()).toBeInstanceOf(RouteNode);
-  })
+  });
 
   describe('→ add nodes', function () {
-    var node = null
+    var node = null;
-    var callback = function () {}
+    var callback = function () {};
-    var context = {}
+    var context = {};
     beforeEach(function () {
-      node = new RouteNode()
+      node = new RouteNode();
-    })
+    });
 
     it('→ add root node', function (done) {
-      node.add([], callback, context)
+      node.add([], callback, context);
       node.get([], [], function (err, func, cbContext, args) {
-        expect(err).toBe(null)
+        expect(err).toBe(null);
-        expect(func).toBe(callback)
+        expect(func).toBe(callback);
-        expect(cbContext).toBe(context)
+        expect(cbContext).toBe(context);
-        expect(args).toEqual([])
+        expect(args).toEqual([]);
-        done()
+        done();
-      })
+      });
-    })
+    });
 
     it('→ get nested callback', function (done) {
-      node.add(['nested'], callback, context)
+      node.add(['nested'], callback, context);
       node.get(['nested'], [], function (err, func, cbContext, args) {
-        expect(err).toBe(null)
+        expect(err).toBe(null);
-        expect(func).toBe(callback)
+        expect(func).toBe(callback);
-        expect(cbContext).toBe(context)
+        expect(cbContext).toBe(context);
-        expect(args).toEqual([])
+        expect(args).toEqual([]);
-        done()
+        done();
-      })
+      });
-    })
+    });
 
     it('→ get error callback for not found', function (done) {
       node.get(['fake', 'route'], [], function (err, func, cbContext, args) {
-        expect(err).toBeInstanceOf(Error)
+        expect(err).toBeInstanceOf(Error);
-        expect(err.message).toMatch(/not found/)
+        expect(err.message).toMatch(/not found/);
-        expect(func).not.toBeDefined()
+        expect(func).not.toBeDefined();
-        expect(cbContext).not.toBeDefined()
+        expect(cbContext).not.toBeDefined();
-        expect(args).not.toBeDefined()
+        expect(args).not.toBeDefined();
-        done()
+        done();
-      })
+      });
-    })
+    });
 
     it('→ get route with regex', function (done) {
-      node.add(['by', 'id', /\d+/], callback, context)
+      node.add(['by', 'id', /\d+/], callback, context);
       node.get(['by', 'id', '123'], [], function (err, func, cbContext, args) {
-        expect(err).toBe(null)
+        expect(err).toBe(null);
-        expect(func).toBe(callback)
+        expect(func).toBe(callback);
-        expect(cbContext).toBe(context)
+        expect(cbContext).toBe(context);
-        expect(args).toEqual(['123'])
+        expect(args).toEqual(['123']);
-        done()
+        done();
-      })
+      });
-    })
+    });
 
     it('→ get route with function', function (done) {
       function toInt(part) {
-        var results = /^(\d+)$/.exec(part)
+        var results = /^(\d+)$/.exec(part);
         if (results) {
-          return parseInt(results[0], 10)
+          return parseInt(results[0], 10);
         } else {
-          return null
+          return null;
         }
       }
 
-      node.add(['by', 'id', toInt], callback, context)
+      node.add(['by', 'id', toInt], callback, context);
       node.get(['by', 'id', '123'], [], function (err, func, cbContext, args) {
-        expect(err).toBe(null, err && err.message)
+        expect(err).toBe(null, err && err.message);
-        expect(func).toBe(callback)
+        expect(func).toBe(callback);
-        expect(cbContext).toBe(context)
+        expect(cbContext).toBe(context);
-        expect(args).toEqual([123])
+        expect(args).toEqual([123]);
-        done()
+        done();
-      })
+      });
-    })
+    });
 
     it('→ pass arguments to handler before parsing', function (done) {
-      var obj = {}
+      var obj = {};
-      node.add(['id', /\d+/], callback)
+      node.add(['id', /\d+/], callback);
       node.get(['id', '123'], [obj], function (err, cb, ctx, args) {
-        expect(args).toEqual([obj, '123'])
+        expect(args).toEqual([obj, '123']);
-        done()
+        done();
-      })
+      });
-    })
+    });
-
+  });
-  })
+});
-})

test/router.js

@@ -1,150 +1,150 @@
-var expect = require('expect')
+var expect = require('expect');
-var Router = require('../lib/router')
+var Router = require('../lib/router');
-var NotFoundError = require('../lib/error').NotFound
+var NotFoundError = require('../lib/error').NotFound;
 
 describe('Router', function () {
   it('→ exists', function () {
-    expect(Router).toBeDefined()
+    expect(Router).toBeDefined();
-  })
+  });
 
   it('→ add root node', function (done) {
-    var router = new Router()
+    var router = new Router();
-    router.add('/', function () { return 'some value' })
+    router.add('/', function () { return 'some value'; });
     router.route('/', function (err, handlerResult) {
-      expect(err).toBe(null)
+      expect(err).toBe(null);
-      expect(handlerResult).toBe('some value')
+      expect(handlerResult).toBe('some value');
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ add/get nested route', function (done) {
-    var router = new Router()
+    var router = new Router();
-    router.add('/some/path/here', function () { return 'some value' })
+    router.add('/some/path/here', function () { return 'some value'; });
     router.route('/some/path/here', function (err, handlerResult) {
-      expect(err).toBe(null)
+      expect(err).toBe(null);
-      expect(handlerResult).toBe('some value')
+      expect(handlerResult).toBe('some value');
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ partial route is a not found error', function (done) {
-    var router = new Router()
+    var router = new Router();
-    router.add(['/user', /^(\d+)$/], function (number) { return number })
+    router.add(['/user', /^(\d+)$/], function (number) { return number; });
     router.route('/user/', function (err) {
-      expect(err).toBeInstanceOf(NotFoundError)
+      expect(err).toBeInstanceOf(NotFoundError);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ get error in callback for missing handler', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.route('/some/fake/path', function (err, handlerResult) {
-      expect(err).toBeInstanceOf(Error)
+      expect(err).toBeInstanceOf(Error);
-      expect(err.message).toMatch(/not found/)
+      expect(err.message).toMatch(/not found/);
-      expect(handlerResult).not.toBeDefined()
+      expect(handlerResult).not.toBeDefined();
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ get routes based on regex', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.add(['/by/id', /\d+/], function (someId) {
-      expect(someId).toBe('123')
+      expect(someId).toBe('123');
-    })
+    });
 
     router.route('/by/id/123', function (err) {
-      expect(err).toBe(null, err && err.message)
+      expect(err).toBe(null, err && err.message);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ regex routes can return NotFoundError', function (done) {
-    var router = new Router()
+    var router = new Router();
-    router.add(['/by/id', /\d+/], function () {})
+    router.add(['/by/id', /\d+/], function () {});
     router.route('/by/id/not-an-id', function (err) {
-      expect(err).toBeInstanceOf(NotFoundError)
+      expect(err).toBeInstanceOf(NotFoundError);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ get based on regex with multiple captures global', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.add(['by', 'order', /(\d+)/g], function (one, two, three) {
-      expect(one).toBe('1')
+      expect(one).toBe('1');
-      expect(two).toBe('2')
+      expect(two).toBe('2');
-      expect(three).toBe('3')
+      expect(three).toBe('3');
-    })
+    });
 
     router.route('/by/order/1-2-3', function (err) {
-      expect(err).toBe(null, err && err.message)
+      expect(err).toBe(null, err && err.message);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ get based regex with multiple captures not global', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.add(['by', 'order', /(\d+)/], function (one, two, three) {
-      expect(one).toBe('1')
+      expect(one).toBe('1');
-      expect(two).not.toBeDefined()
+      expect(two).not.toBeDefined();
-      expect(three).not.toBeDefined()
+      expect(three).not.toBeDefined();
-    })
+    });
 
     router.route('/by/order/1-2-3', function (err) {
-      expect(err).toBe(null, err && err.message)
+      expect(err).toBe(null, err && err.message);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ pass in arguments before capturing path arguments', function (done) {
-    var router = new Router()
+    var router = new Router();
-    var api = {key: 123, any: 'object is passed', method: function () {}}
+    var api = {key: 123, any: 'object is passed', method: function () {}};
     router.add(['/by/order', /(\d+)/], function (inputApi, urlParam) {
-      expect(inputApi).toBe(api)
+      expect(inputApi).toBe(api);
-      expect(urlParam).toBe('123')
+      expect(urlParam).toBe('123');
-      done()
+      done();
-    })
+    });
 
-    router.route('/by/order/123', {args: [api]})
+    router.route('/by/order/123', {args: [api]});
-  })
+  });
 
   function toInt(part) {
-    var results = /^(\d+)$/.exec(part)
+    var results = /^(\d+)$/.exec(part);
     if (results) {
-      return parseInt(results[0], 10)
+      return parseInt(results[0], 10);
     } else {
-      return null
+      return null;
     }
   }
   it('→ get based on function', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.add(['by', 'order', toInt], function (val) {
-      expect(val).toBe(123)
+      expect(val).toBe(123);
-    })
+    });
 
     router.route('/by/order/123', function (err) {
-      expect(err).toBe(null)
+      expect(err).toBe(null);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ function routes can return NotFoundError', function (done) {
-    var router = new Router()
+    var router = new Router();
-    router.add(['/by/order', toInt], function () {})
+    router.add(['/by/order', toInt], function () {});
     router.route('/by/order/not-found', function (err) {
-      expect(err).toBeInstanceOf(NotFoundError)
+      expect(err).toBeInstanceOf(NotFoundError);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ check not found error', function (done) {
-    var router = new Router()
+    var router = new Router();
     router.route('/not/real/id', function (err) {
-      expect(Router.isNotFound(err)).toBe(true)
+      expect(Router.isNotFound(err)).toBe(true);
-      done()
+      done();
-    })
+    });
-  })
+  });
 
   it('→ check not found error on not real error', function () {
-    expect(Router.isNotFound(new Error('Not the missing error'))).toBe(false)
+    expect(Router.isNotFound(new Error('Not the missing error'))).toBe(false);
-  })
+  });
-})
+});

test/utils.js

@@ -1,114 +1,115 @@
-var expect = require('expect')
+var expect = require('expect');
-var utils = require('../lib/utils')
+var utils = require('../lib/utils');
 
-var assign = utils.assign
+var assign = utils.assign;
-var forEach = utils.forEach
+var forEach = utils.forEach;
-var isArray = utils.isArray
+var isArray = utils.isArray;
-var isFunction = utils.isFunction
+var isFunction = utils.isFunction;
-var isRegExp = utils.isRegExp
+var isRegExp = utils.isRegExp;
-var isString = utils.isString
+var isString = utils.isString;
-var noop = utils.noop
+var noop = utils.noop;
 
 function SomeClass (foo) {
-  this.foo = foo
+  this.foo = foo;
 }
-SomeClass.prototype.bar = 'asdf'
+
+SomeClass.prototype.bar = 'asdf';
 
 describe('utils', function () {
   it('→ exists', function () {
-    expect(utils).toBeDefined()
+    expect(utils).toBeDefined();
-  })
+  });
 
   describe('→ noop', function () {
     it('→ is a function', function () {
-      expect(noop).toBeInstanceOf(Function)
+      expect(noop).toBeInstanceOf(Function);
-    })
+    });
-  })
+  });
 
   describe('→ isString', function () {
     it('→ true for strings', function () {
-      expect(isString('is string')).toBe(true)
+      expect(isString('is string')).toBe(true);
-    })
+    });
 
     it('→ false for not strings', function () {
-      expect(isString(/is string/)).toBe(false)
+      expect(isString(/is string/)).toBe(false);
-    })
+    });
-  })
+  });
 
   describe('→ isRegExp', function () {
     it('→ true for regex', function () {
-      expect(isRegExp(/some regex/)).toBe(true)
+      expect(isRegExp(/some regex/)).toBe(true);
-    })
+    });
 
     it('→ false for strings', function () {
-      expect(isRegExp('some string')).toBe(false)
+      expect(isRegExp('some string')).toBe(false);
-    })
+    });
-  })
+  });
 
   describe('→ isArray', function () {
     it('→ true for array', function () {
-      expect(isArray([])).toBe(true)
+      expect(isArray([])).toBe(true);
-    })
+    });
 
     it('→ false for regex', function () {
-      expect(isArray(/some regex/)).toBe(false)
+      expect(isArray(/some regex/)).toBe(false);
-    })
+    });
 
     it('→ false for strings', function () {
-      expect(isArray('some string')).toBe(false)
+      expect(isArray('some string')).toBe(false);
-    })
+    });
-  })
+  });
 
   describe('→ isFunction', function () {
     it('→ true for function', function () {
-      expect(isFunction(function () {})).toBe(true)
+      expect(isFunction(function () {})).toBe(true);
-    })
+    });
 
     it('→ false for array', function () {
-      expect(isFunction([])).toBe(false)
+      expect(isFunction([])).toBe(false);
-    })
+    });
 
     it('→ false for regex', function () {
-      expect(isFunction(/some regex/)).toBe(false)
+      expect(isFunction(/some regex/)).toBe(false);
-    })
+    });
 
     it('→ false for strings', function () {
-      expect(isFunction('some string')).toBe(false)
+      expect(isFunction('some string')).toBe(false);
-    })
+    });
-  })
+  });
 
   describe('→ forEach', function () {
     it('→ does not call properties on prototype', function () {
-      var count = 0
+      var count = 0;
       forEach(new SomeClass(123), function (key, value) {
-        count += 1
+        count += 1;
-        expect(key).toBe('foo')
+        expect(key).toBe('foo');
-        expect(value).toBe(123)
+        expect(value).toBe(123);
-      })
+      });
-      expect(count).toEqual(1)
+      expect(count).toEqual(1);
-    })
+    });
-  })
+  });
 
   describe('→ assign', function () {
     it('→ adds properties to dest', function () {
-      var dest = {}
+      var dest = {};
-      var src = {foo: 123, bar: 'asdf'}
+      var src = {foo: 123, bar: 'asdf'};
-      assign(dest, src)
+      assign(dest, src);
-      expect(dest).toEqual({foo: 123, bar: 'asdf'})
+      expect(dest).toEqual({foo: 123, bar: 'asdf'});
-    })
+    });
 
     it('→ overrides properties to dest', function () {
-      var dest = {foo: 456, bar: 'qwerty', blah: /foo/}
+      var dest = {foo: 456, bar: 'qwerty', blah: /foo/};
-      var src = {foo: 123, bar: 'asdf'}
+      var src = {foo: 123, bar: 'asdf'};
-      assign(dest, src)
+      assign(dest, src);
-      expect(dest).toEqual({foo: 123, bar: 'asdf', blah: /foo/})
+      expect(dest).toEqual({foo: 123, bar: 'asdf', blah: /foo/});
-    })
+    });
 
     it('→ does not overrides properties on prototype', function () {
-      var dest = {foo: 456, bar: 'qwerty', blah: /foo/}
+      var dest = {foo: 456, bar: 'qwerty', blah: /foo/};
-      assign(dest, new SomeClass(123))
+      assign(dest, new SomeClass(123));
 
-      expect(dest).toEqual({foo: 123, bar: 'qwerty', blah: /foo/})
+      expect(dest).toEqual({foo: 123, bar: 'qwerty', blah: /foo/});
-    })
+    });
-  })
+  });
-})
+});