diff --git a/.eslintrc.json b/.eslintrc.json
index 48cb1d9f..3fbbf51d 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -7,7 +7,7 @@
         "setFixtures": true  // added globally by jasmine-jquery (bad)
     },
     "rules": {
-        "indent": ["error", 4],
+        "indent": "off",
         "func-names": "off",
         "import/no-extraneous-dependencies": "off",
         "object-shorthand": "off",
@@ -19,6 +19,21 @@
         "one-var-declaration-per-line": "off",
         "import/no-amd": "off",
         "no-param-reassign": "off",
-        "new-cap": "off"
+        "new-cap": "off",
+        "comma-dangle": "off",
+        "object-curly-spacing": "off",
+        "space-before-function-paren": "off",
+        "prefer-template": "off",
+        "operator-linebreak": "off",
+        "no-multi-spaces": "off",
+        "prefer-spread": "off",
+        "prefer-rest-params": "off",
+        "no-else-return": "off",
+        "no-multiple-empty-lines": "off",
+        "prefer-destructuring": "off",
+        "no-buffer-constructor": "off",
+        "import/order": "off",
+        "import/extensions": "off",
+        "import/no-dynamic-require": "off"
     }
 }
diff --git a/doc/static/js/ui-toolkit-doc-factory.js b/doc/static/js/ui-toolkit-doc-factory.js
index 264bfb92..13f62177 100644
--- a/doc/static/js/ui-toolkit-doc-factory.js
+++ b/doc/static/js/ui-toolkit-doc-factory.js
@@ -1,12 +1,11 @@
-// eslint-disable-next-line import/no-dynamic-require
 require(
     [
         'jquery',
         'edx-pattern-library/js/modernizr-custom',
         'edx-pattern-library/js/afontgarde',
-        'edx-pattern-library/js/edx-icons',
+        'edx-pattern-library/js/edx-icons'
     ],
-    function () {
+    function() {
         'use strict';
-    },
+    }
 );
diff --git a/gulp/config.js b/gulp/config.js
index 6a89aa7f..47d8f941 100644
--- a/gulp/config.js
+++ b/gulp/config.js
@@ -6,46 +6,46 @@ module.exports = {
         previewTargetDir: './_preview_site',
         testing: {
             sources: [
-                './src/js/utils/spec-helpers/*.js',
+                './src/js/utils/spec-helpers/*.js'
             ],
             output: './doc/_testing',
-            viewClass: 'testing',
+            viewClass: 'testing'
         },
         utilities: {
             sources: [
-                './src/js/utils/*.js',
+                './src/js/utils/*.js'
             ],
             output: './doc/_utilities',
-            viewClass: 'utility',
+            viewClass: 'utility'
         },
         views: {
             sources: [
-                './src/js/!(utils)/*.js',
+                './src/js/!(utils)/*.js'
             ],
             output: './doc/_views',
-            viewClass: 'view',
+            viewClass: 'view'
         },
         browserSync: {
             server: {
-                baseDir: './_site',
+                baseDir: './_site'
             },
             ui: {
                 port: 5000,
                 weinre: {
-                    port: 5002,
-                },
-            },
+                    port: 5002
+                }
+            }
         },
         templates: [
             './doc/*.md',
             './doc/_data/**/*',
-            './doc/_layouts/**/*',
+            './doc/_layouts/**/*'
         ],
         static: [
-            './doc/static/**/*',
+            './doc/static/**/*'
         ],
         gitHubPages: {
-            files: './_site/**/*',
-        },
-    },
+            files: './_site/**/*'
+        }
+    }
 };
diff --git a/gulp/tasks/clean.js b/gulp/tasks/clean.js
index ce656aa1..c8b25aff 100644
--- a/gulp/tasks/clean.js
+++ b/gulp/tasks/clean.js
@@ -1,10 +1,10 @@
 'use strict';
 
 var gulp = require('gulp'),
-    del = require('del'),
-    config = require('../config');
+    config = require('../config'),
+    del = require('del');
 
-gulp.task('clean', function () {
+gulp.task('clean', function() {
     return del([
         // Remove the Jekyll site
         config.documentation.targetDir,
@@ -15,7 +15,7 @@ gulp.task('clean', function () {
         // Remove the JSDoc generated markdown
         config.documentation.testing.output,
         config.documentation.utilities.output,
-        config.documentation.views.output,
+        config.documentation.views.output
     ]);
 });
 
diff --git a/gulp/tasks/coverage.js b/gulp/tasks/coverage.js
index 4ef7ef00..b18a4265 100644
--- a/gulp/tasks/coverage.js
+++ b/gulp/tasks/coverage.js
@@ -3,7 +3,7 @@
 var gulp = require('gulp'),
     coveralls = require('gulp-coveralls');
 
-gulp.task('coverage', function () {
+gulp.task('coverage', function() {
     return gulp.src('coverage/**/lcov.info')
         .pipe(coveralls());
 });
diff --git a/gulp/tasks/default.js b/gulp/tasks/default.js
index f46522de..56cbb3a0 100644
--- a/gulp/tasks/default.js
+++ b/gulp/tasks/default.js
@@ -8,5 +8,5 @@ var gulp = require('gulp'),
 exports.default = gulp.series(
     lint.lint,
     test.test,
-    doc.docBuild,
+    doc.docBuild
 );
diff --git a/gulp/tasks/doc.js b/gulp/tasks/doc.js
index 4848e658..ab07eb60 100644
--- a/gulp/tasks/doc.js
+++ b/gulp/tasks/doc.js
@@ -12,55 +12,55 @@ var gulp = require('gulp'),
     childProcess = require('child_process'),
     browserSync = require('browser-sync'),
     runSequence = require('gulp4-run-sequence'),
+    config = require('../config').documentation,
+    generateDoc = require('../utils/generate-doc'),
     rename = require('gulp-rename'),
     webpack = require('webpack'),
     webpackStream = require('webpack-stream'),
     ghPages = require('gulp-gh-pages'),
-    config = require('../config').documentation,
-    generateDoc = require('../utils/generate-doc'),
-    webpackConfig = require('../../webpack.config.js'), // eslint-disable-line import/extensions
+    webpackConfig = require('../../webpack.config.js'),
     clean = require('./clean'),
     renameAsMarkdown,
     generateDocFor;
 
-renameAsMarkdown = function (path) {
+renameAsMarkdown = function(path) {
     var renamedPath = path;
     renamedPath.extname = '.md';
     return renamedPath;
 };
 
-generateDocFor = function (options) {
+generateDocFor = function(options) {
     var i, sources,
         sourceLength = options.sources.length;
     for (i = 0; i < sourceLength; i += 1) {
         sources = options.sources[i];
-        console.log(`Generating documentation for ${sources}`);
-        gulp.src(sources, { buffer: false })
+        console.log('Generating documentation for ' + sources);
+        gulp.src(sources, {buffer: false})
             .pipe(generateDoc(options.viewClass))
             .pipe(rename(renameAsMarkdown))
             .pipe(gulp.dest(options.output));
     }
 };
 
-gulp.task('doc', function (callback) {
+gulp.task('doc', function(callback) {
     runSequence(
         'doc-build',
         'doc-serve',
-        callback,
+        callback
     );
 });
 
-gulp.task('doc-build', function (callback) {
+gulp.task('doc-build', function(callback) {
     runSequence(
         ['doc-testing', 'doc-utils', 'doc-views'],
         'copy-pattern-library',
         'webpack',
         'jekyll-build',
-        callback,
+        callback
     );
 });
 
-gulp.task('doc-serve', function (callback) {
+gulp.task('doc-serve', function(callback) {
     // Run browserSync to serve the doc site
     browserSync(config.browserSync);
 
@@ -77,53 +77,53 @@ gulp.task('doc-serve', function (callback) {
     callback();
 });
 
-gulp.task('doc-testing', function (callback) {
+gulp.task('doc-testing', function(callback) {
     generateDocFor(config.testing);
     callback();
 });
 
-gulp.task('doc-utils', function (callback) {
+gulp.task('doc-utils', function(callback) {
     generateDocFor(config.utilities);
     callback();
 });
 
-gulp.task('doc-views', function (callback) {
+gulp.task('doc-views', function(callback) {
     generateDocFor(config.views);
     callback();
 });
 
-gulp.task('copy-pattern-library', function (callback) {
+gulp.task('copy-pattern-library', function(callback) {
     gulp.src(['./node_modules/edx-pattern-library/pattern-library/**/*'])
         .pipe(gulp.dest('doc/public/edx-pattern-library'));
     callback();
 });
 
-gulp.task('webpack', function () {
-    return gulp.src('.', { allowEmpty: true })
+gulp.task('webpack', function() {
+    return gulp.src('.', {allowEmpty: true})
         .pipe(webpackStream(webpackConfig, webpack))
         .pipe(gulp.dest(webpackConfig.output.path))
         .pipe(browserSync.stream());
 });
 
-gulp.task('webpack-rebuild', function (callback) {
+gulp.task('webpack-rebuild', function(callback) {
     runSequence(
         'webpack',
         'jekyll-rebuild',
-        callback,
+        callback
     );
 });
 
-gulp.task('jekyll-build', function (callback) {
+gulp.task('jekyll-build', function(callback) {
     childProcess.execSync('jekyll build');
     callback();
 });
 
-gulp.task('jekyll-rebuild', gulp.series('jekyll-build', function (callback) {
+gulp.task('jekyll-rebuild', gulp.series('jekyll-build', function(callback) {
     browserSync.reload();
     callback();
 }));
 
-gulp.task('doc-publish', gulp.series(clean.clean, 'doc-build', function () {
+gulp.task('doc-publish', gulp.series(clean.clean, 'doc-build', function() {
     return gulp.src(config.gitHubPages.files)
         .pipe(ghPages());
 }));
@@ -132,5 +132,5 @@ exports.docBuild = gulp.series(
     gulp.parallel('doc-testing', 'doc-utils', 'doc-views'),
     'copy-pattern-library',
     'webpack',
-    'jekyll-build',
+    'jekyll-build'
 );
diff --git a/gulp/tasks/preview.js b/gulp/tasks/preview.js
index 0a79aae3..4c0f52df 100644
--- a/gulp/tasks/preview.js
+++ b/gulp/tasks/preview.js
@@ -20,11 +20,11 @@ var gulp = require('gulp'),
     webpackStream = require('webpack-stream'),
     gitUtils = require('../utils/git-utils'),
     config = require('../config').documentation,
-    webpackConfig = require('../../webpack.config.js'), // eslint-disable-line import/extensions
+    webpackConfig = require('../../webpack.config.js'),
     previewConfigFile = '_tmp_preview_config.yml',
     previewDomain = process.env.S3_PREVIEW_DOMAIN;
 
-gulp.task('preview', function (callback) {
+gulp.task('preview', function(callback) {
     runSequence(
         'clean',
         'doc-build',
@@ -32,62 +32,62 @@ gulp.task('preview', function (callback) {
         'preview-webpack',
         'upload-preview',
         'show-preview',
-        callback,
+        callback
     );
 });
 
-gulp.task('jekyll-build-preview', function () {
+gulp.task('jekyll-build-preview', function() {
     var branch = gitUtils.currentBranch(),
-        previewBaseUrl = `/${branch}/`;
+        previewBaseUrl = '/' + branch + '/';
     // Create a temporary Jekyll configuration file which specifies the base URL for the preview site
     childProcess.execSync(
-        `echo 'baseurl: ${previewBaseUrl}' > ${previewConfigFile}`,
+        'echo \'baseurl: ' + previewBaseUrl + '\' > ' + previewConfigFile
     );
 
     // Generate the preview version of the site
-    console.log(`Generating preview for branch ${branch}`);
+    console.log('Generating preview for branch ' + branch);
     childProcess.execSync(
-        `jekyll build --config _config.yml,${previewConfigFile} --destination ${config.previewTargetDir}`,
+        'jekyll build --config _config.yml,' + previewConfigFile + ' --destination ' + config.previewTargetDir
     );
 
     // Remove the configuration file since it is no longer needed
-    childProcess.execSync(`rm ${previewConfigFile}`);
+    childProcess.execSync('rm ' + previewConfigFile);
 });
 
-gulp.task('preview-webpack', function () {
-    var outputPath = `${config.previewTargetDir}/public/`,
+gulp.task('preview-webpack', function() {
+    var outputPath = config.previewTargetDir + '/public/',
         branch = gitUtils.currentBranch();
-    process.env.SITE_ROOT = `/${branch}/`;
+    process.env.SITE_ROOT = '/' + branch + '/';
     return gulp.src('')
         .pipe(webpackStream(webpackConfig, webpack))
         .pipe(gulp.dest(outputPath));
 });
 
-gulp.task('upload-preview', function () {
+gulp.task('upload-preview', function() {
     var branch = gitUtils.currentBranch();
     if (previewDomain) {
         childProcess.execSync(
-            `aws s3 sync ${config.previewTargetDir} s3://${previewDomain}/${branch}`,
+            'aws s3 sync ' + config.previewTargetDir + ' s3://' + previewDomain + '/' + branch
         );
-        console.log(`Preview site ready at http://${previewDomain}/${branch}`);
+        console.log('Preview site ready at http://' + previewDomain + '/' + branch);
     } else {
         console.log(
-            'No preview domain specified. Please export environment variable S3_PREVIEW_DOMAIN and try again.',
+            'No preview domain specified. Please export environment variable S3_PREVIEW_DOMAIN and try again.'
         );
     }
 });
 
-gulp.task('remove-preview', function () {
+gulp.task('remove-preview', function() {
     var branch = gitUtils.currentBranch();
     childProcess.execSync(
-        `aws s3 rm --recursive  s3://${previewDomain}/${branch}`,
+        'aws s3 rm --recursive  s3://' + previewDomain + '/' + branch
     );
-    console.log(`Removed preview for branch ${branch}`);
+    console.log('Removed preview for branch ' + branch);
 });
 
-gulp.task('show-preview', function () {
+gulp.task('show-preview', function() {
     var branch = gitUtils.currentBranch();
     childProcess.execSync(
-        `open http://${previewDomain}/${branch}`,
+        'open http://' + previewDomain + '/' + branch
     );
 });
diff --git a/gulp/tasks/test-debug.js b/gulp/tasks/test-debug.js
index 00339d06..a892094f 100644
--- a/gulp/tasks/test-debug.js
+++ b/gulp/tasks/test-debug.js
@@ -5,8 +5,8 @@ var gulp = require('gulp'),
     path = require('path'),
     configFile = 'test/karma.debug.conf.js';
 
-gulp.task('test-debug', function (callback) {
+gulp.task('test-debug', function(callback) {
     new karma.Server({
-        configFile: path.resolve(configFile),
+        configFile: path.resolve(configFile)
     }, callback).start();
 });
diff --git a/gulp/tasks/test.js b/gulp/tasks/test.js
index 906f3ac9..77f1573d 100644
--- a/gulp/tasks/test.js
+++ b/gulp/tasks/test.js
@@ -5,14 +5,15 @@ var gulp = require('gulp'),
     path = require('path'),
     configFile;
 
-gulp.task('test', function (callback) {
+
+gulp.task('test', function(callback) {
     if (process.argv.indexOf('--ci') !== -1) {
         configFile = 'test/karma.ci.conf.js';
     } else {
         configFile = 'test/karma.conf.js';
     }
     new karma.Server({
-        configFile: path.resolve(configFile),
+        configFile: path.resolve(configFile)
     }, callback).start();
 });
 
diff --git a/gulp/utils/generate-doc.js b/gulp/utils/generate-doc.js
index 26c80e6c..c680e6b8 100644
--- a/gulp/utils/generate-doc.js
+++ b/gulp/utils/generate-doc.js
@@ -6,15 +6,15 @@ var jsdox = require('jsdox'),
     GulpUtil = require('gulp-util'),
     jsdocParser = require('jsdoc3-parser'),
     PLUGIN_NAME = 'generate-doc',
-    { analyze } = jsdox,
-    { generateMD } = jsdox,
+    analyze = jsdox.analyze,
+    generateMD = jsdox.generateMD,
     jsdoxTemplatesDir = 'node_modules/jsdox/templates';
 
-module.exports = function (viewClass) {
-    return through.obj(function (file, enc, next) {
+module.exports = function(viewClass) {
+    return through.obj(function(file, enc, next) {
         var self = this;
         if (file.isStream()) {
-            jsdocParser(file.history, function (err, result) {
+            jsdocParser(file.history, function(err, result) {
                 var frontMatter, data, markdown, title, relativePath, requirePath, gitHubPath,
                     fileToPush = file;
                 if (err) {
@@ -23,18 +23,22 @@ module.exports = function (viewClass) {
                 } else {
                     // Generate the front matter
                     relativePath = path.relative(path.resolve('src'), file.path);
-                    requirePath = `edx-ui-toolkit/${relativePath.slice(0, -3)}`;
-                    gitHubPath = `blob/master/src/${relativePath}`;
+                    requirePath = 'edx-ui-toolkit/' + relativePath.slice(0, -3);
+                    gitHubPath = 'blob/master/src/' + relativePath;
                     // title = path.relative(path.resolve('src/js'), file.path).slice(0, -3);
                     title = path.basename(file.path, '.js');
-                    frontMatter = `---\ntitle: ${title}\nrequirePath: ${requirePath}\ngithubPath: ${gitHubPath}\nviewClass: ${viewClass}\n---\n\n`;
+                    frontMatter = '---\n' +
+                        'title: ' + title + '\n' +
+                        'requirePath: ' + requirePath + '\n' +
+                        'githubPath: ' + gitHubPath + '\n' +
+                        'viewClass: ' + viewClass + '\n' +
+                        '---\n\n';
 
                     // Generate the markdown
                     data = analyze(result, {});
                     markdown = generateMD(data, jsdoxTemplatesDir);
 
                     // set the result to the front matter followed by the markdown
-                    // eslint-disable-next-line no-buffer-constructor
                     fileToPush.contents = new Buffer(frontMatter + markdown);
                 }
                 self.push(fileToPush);
diff --git a/gulp/utils/git-utils.js b/gulp/utils/git-utils.js
index 9c0982aa..7d354293 100644
--- a/gulp/utils/git-utils.js
+++ b/gulp/utils/git-utils.js
@@ -7,8 +7,8 @@ module.exports = {
     /**
      * Returns the current Git branch for the current directory.
      */
-    currentBranch: function () {
+    currentBranch: function() {
         var branch = childProcess.execSync(gitBranchCommand);
         return branch.toString().trim();
-    },
+    }
 };
diff --git a/src/js/breadcrumbs/breadcrumbs-model.js b/src/js/breadcrumbs/breadcrumbs-model.js
index 96754e4c..963695e2 100644
--- a/src/js/breadcrumbs/breadcrumbs-model.js
+++ b/src/js/breadcrumbs/breadcrumbs-model.js
@@ -20,15 +20,15 @@
  *~~~
  * @module BreadcrumbsModel
  */
-(function (define) {
+(function(define) {
     'use strict';
 
-    define(['backbone'], function (Backbone) {
+    define(['backbone'], function(Backbone) {
         var BreadcrumbsModel = Backbone.Model.extend({
             defaults: {
                 breadcrumbs: null,
-                label: '',
-            },
+                label: ''
+            }
         });
 
         return BreadcrumbsModel;
@@ -36,5 +36,5 @@
 }).call(
     this,
     // Use the default 'define' function if available, else use 'RequireJS.define'
-    typeof define === 'function' && define.amd ? define : RequireJS.define,
+    typeof define === 'function' && define.amd ? define : RequireJS.define
 );
diff --git a/src/js/breadcrumbs/breadcrumbs-view.js b/src/js/breadcrumbs/breadcrumbs-view.js
index e2cfda0b..0c5e72ed 100644
--- a/src/js/breadcrumbs/breadcrumbs-view.js
+++ b/src/js/breadcrumbs/breadcrumbs-view.js
@@ -19,23 +19,23 @@
  *~~~
  * @module BreadcrumbsView
  */
-(function (define) {
+(function(define) {
     'use strict';
 
     define(['backbone', 'edx-ui-toolkit/js/utils/html-utils', 'text!./breadcrumbs.underscore'],
-        function (Backbone, HtmlUtils, breadcrumbsTemplate) {
+        function(Backbone, HtmlUtils, breadcrumbsTemplate) {
             var BreadcrumbsView = Backbone.View.extend({
-                initialize: function () {
+                initialize: function() {
                     this.template = HtmlUtils.template(breadcrumbsTemplate);
                     this.listenTo(this.model, 'change', this.render);
                     this.render();
                 },
 
-                render: function () {
+                render: function() {
                     var json = this.model.attributes;
                     HtmlUtils.setHtml(this.$el, this.template(json));
                     return this;
-                },
+                }
             });
 
             return BreadcrumbsView;
@@ -43,5 +43,5 @@
 }).call(
     this,
     // Use the default 'define' function if available, else use 'RequireJS.define'
-    typeof define === 'function' && define.amd ? define : RequireJS.define,
+    typeof define === 'function' && define.amd ? define : RequireJS.define
 );
diff --git a/src/js/breadcrumbs/specs/breadcrumbs-spec.js b/src/js/breadcrumbs/specs/breadcrumbs-spec.js
index f80d9b45..4d107ee5 100644
--- a/src/js/breadcrumbs/specs/breadcrumbs-spec.js
+++ b/src/js/breadcrumbs/specs/breadcrumbs-spec.js
@@ -1,4 +1,4 @@
-(function (define) {
+(function(define) {
     'use strict';
 
     define([
@@ -6,61 +6,61 @@
         '../../utils/html-utils.js',
         '../../utils/spec-helpers/spec-helpers.js',
         '../breadcrumbs-view.js',
-        '../breadcrumbs-model.js',
+        '../breadcrumbs-model.js'
     ],
-    function ($, HtmlUtils, SpecHelpers, BreadcrumbsView, BreadcrumbsModel) {
-        describe('BreadcrumbsView', function () {
-            var model, view;
+           function($, HtmlUtils, SpecHelpers, BreadcrumbsView, BreadcrumbsModel) {
+               describe('BreadcrumbsView', function() {
+                   var model, view;
 
-            beforeEach(function () {
-                model = new BreadcrumbsModel();
-                view = new BreadcrumbsView({
-                    model: model,
-                });
-            });
+                   beforeEach(function() {
+                       model = new BreadcrumbsModel();
+                       view = new BreadcrumbsView({
+                           model: model
+                       });
+                   });
 
-            it('does not show breadcrumbs by default', function () {
-                expect(view.$el.html()).not.toContain('<nav class="breadcrumbs">');
-            });
+                   it('does not show breadcrumbs by default', function() {
+                       expect(view.$el.html()).not.toContain('<nav class="breadcrumbs">');
+                   });
 
-            SpecHelpers.withData({
-                'with no breadcrumbs': [[]],
-                'with one breadcrumb': [[
-                    { url: 'url1', title: 'Crumb 1' },
-                ]],
-                'with two breadcrumbs': [[
-                    { url: 'url1', title: 'Crumb 1' },
-                    { url: 'url2', title: 'Crumb 2' },
-                ]],
-                'with unicode breadcrumbs': [[
-                    { url: '', title: '☃' },
-                ]],
-                'with breadcrumbs containing HTML': [[
-                    { url: '', title: '<h1>crumb!</h1>' },
-                ]],
-            }, function (breadcrumbs) {
-                var crumbs, linkCrumbs, lastCrumb;
+                   SpecHelpers.withData({
+                       'with no breadcrumbs': [[]],
+                       'with one breadcrumb': [[
+                           {url: 'url1', title: 'Crumb 1'}
+                       ]],
+                       'with two breadcrumbs': [[
+                           {url: 'url1', title: 'Crumb 1'},
+                           {url: 'url2', title: 'Crumb 2'}
+                       ]],
+                       'with unicode breadcrumbs': [[
+                           {url: '', title: '☃'}
+                       ]],
+                       'with breadcrumbs containing HTML': [[
+                           {url: '', title: '<h1>crumb!</h1>'}
+                       ]]
+                   }, function(breadcrumbs) {
+                       var crumbs, linkCrumbs, lastCrumb;
 
-                model.set('breadcrumbs', breadcrumbs);
+                       model.set('breadcrumbs', breadcrumbs);
 
-                crumbs = view.$('.nav-item');
-                linkCrumbs = crumbs.slice(0, -1);
+                       crumbs = view.$('.nav-item');
+                       linkCrumbs = crumbs.slice(0, -1);
 
-                expect(crumbs.length).toBe(breadcrumbs.length);
+                       expect(crumbs.length).toBe(breadcrumbs.length);
 
-                linkCrumbs.each(function (index, el) {
-                    expect($('a', el).attr('href')).toEqual(breadcrumbs[index].url);
-                    expect($('a', el).text()).toEqual(breadcrumbs[index].title);
-                });
+                       linkCrumbs.each(function(index, el) {
+                           expect($('a', el).attr('href')).toEqual(breadcrumbs[index].url);
+                           expect($('a', el).text()).toEqual(breadcrumbs[index].title);
+                       });
 
-                if (crumbs.length > 0) {
-                    // The last crumb is not a link
-                    lastCrumb = crumbs.length - 1;
-                    expect(crumbs.eq(lastCrumb).text()).toEqual(breadcrumbs[lastCrumb].title);
-                    expect(crumbs.eq(lastCrumb).is('a')).toBeFalsy();
-                }
-            });
-        });
-    },
-    );
+                       if (crumbs.length > 0) {
+                           // The last crumb is not a link
+                           lastCrumb = crumbs.length - 1;
+                           expect(crumbs.eq(lastCrumb).text()).toEqual(breadcrumbs[lastCrumb].title);
+                           expect(crumbs.eq(lastCrumb).is('a')).toBeFalsy();
+                       }
+                   });
+               });
+           }
+          );
 }).call(this, define || RequireJS.define);
diff --git a/src/js/disclosure/disclosure-view.js b/src/js/disclosure/disclosure-view.js
index ea778fcf..aab04d67 100644
--- a/src/js/disclosure/disclosure-view.js
+++ b/src/js/disclosure/disclosure-view.js
@@ -8,19 +8,19 @@
  *
  * @module DisclosureView
  */
-(function (define) {
+(function(define) {
     'use strict';
 
     define(['backbone', 'underscore'],
-        function (Backbone, _) {
+        function(Backbone, _) {
             var DisclosureView = Backbone.View.extend({
 
-                initialize: function (options) {
+                initialize: function(options) {
                     var self = this;
                     self.options = _.defaults(options, {
                         toggleTextSelector: '.disclosure-toggle',
                         disclosureSelector: '.disclosure-target',
-                        isCollapsedClass: 'is-collapsed',
+                        isCollapsedClass: 'is-collapsed'
                     });
                     self.render();
                 },
@@ -30,7 +30,7 @@
                  *
                  * @param {boolean} isVisible True if the section should be visible (default: false).
                  */
-                toggleState: function (isVisible) {
+                toggleState: function(isVisible) {
                     var self = this,
                         $textEl = self.$el.find(self.options.toggleTextSelector);
 
@@ -43,7 +43,7 @@
                     self.$el.toggleClass(self.options.isCollapsedClass, !isVisible);
                 },
 
-                render: function () {
+                render: function() {
                     var self = this,
                         $disclosureEl = self.$el.find(self.options.disclosureSelector),
                         $textEl = self.$el.find(self.options.toggleTextSelector);
@@ -52,7 +52,7 @@
                     self.toggleState($disclosureEl.is(':visible'));
 
                     // clicking on the toggle text will hide/show content and update text
-                    $textEl.click(function () {
+                    $textEl.click(function() {
                         // Get the state now because getting it after toggling isn't  always accurate -- state is
                         // in transition
                         var isVisible = $disclosureEl.is(':visible');
@@ -61,15 +61,15 @@
                     });
 
                     return self;
-                },
+                }
 
             });
 
             return DisclosureView;
-        },
+        }
     );
 }).call(
     this,
     // Use the default 'define' function if available, else use 'RequireJS.define'
-    typeof define === 'function' && define.amd ? define : RequireJS.define,
+    typeof define === 'function' && define.amd ? define : RequireJS.define
 );
diff --git a/src/js/disclosure/specs/disclosure-view-spec.js b/src/js/disclosure/specs/disclosure-view-spec.js
index 325ea437..ccdfc901 100644
--- a/src/js/disclosure/specs/disclosure-view-spec.js
+++ b/src/js/disclosure/specs/disclosure-view-spec.js
@@ -1,13 +1,13 @@
-define(['jquery', '../disclosure-view.js'], function ($, DisclosureView) {
+define(['jquery', '../disclosure-view.js'], function($, DisclosureView) {
     'use strict';
 
-    describe('Disclosure view', function () {
-        it('should display toggle display', function () {
+    describe('Disclosure view', function() {
+        it('should display toggle display', function() {
             var disclosureEl = document.createElement('div'),
                 toggleText = document.createElement('div'),
                 toggleContent = document.createElement('div'),
                 view = new DisclosureView({
-                    el: disclosureEl,
+                    el: disclosureEl
                 });
 
             // for testing visibility
diff --git a/src/js/dropdown-menu/dropdown-menu-view.js b/src/js/dropdown-menu/dropdown-menu-view.js
index 6fd6119c..69d0729f 100644
--- a/src/js/dropdown-menu/dropdown-menu-view.js
+++ b/src/js/dropdown-menu/dropdown-menu-view.js
@@ -33,7 +33,7 @@
  *~~~
  * @module DropdownMenuView
  */
-(function (define) {
+(function(define) {
     'use strict';
 
     define([
@@ -41,60 +41,59 @@
         'jquery',
         'underscore',
         'edx-ui-toolkit/js/utils/constants',
-        'text!./dropdown.underscore',
+        'text!./dropdown.underscore'
     ],
-    function (Backbone, $, _, constants, DropdownTpl) {
-        var DropdownMenuView = Backbone.View.extend({
-            tpl: _.template(DropdownTpl),
+        function(Backbone, $, _, constants, DropdownTpl) {
+            var DropdownMenuView = Backbone.View.extend({
+                tpl: _.template(DropdownTpl),
 
-            events: {
-                'click .js-dropdown-button': 'clickOpenDropdown',
-                'click a': 'analyticsLinkClick',
-                keydown: 'viewKeypress',
-            },
+                events: {
+                    'click .js-dropdown-button': 'clickOpenDropdown',
+                    'click a': 'analyticsLinkClick',
+                    keydown: 'viewKeypress'
+                },
 
-            dropdownButton: '.js-dropdown-button',
+                dropdownButton: '.js-dropdown-button',
 
-            menu: '.dropdown-menu',
+                menu: '.dropdown-menu',
 
-            initialize: function (options) {
-                if (options.parent) {
-                    this.$parent = $(options.parent);
-                }
+                initialize: function(options) {
+                    if (options.parent) {
+                        this.$parent = $(options.parent);
+                    }
 
-                // eslint-disable-next-line prefer-template
-                this.menuId = options.menuId || 'dropdown-menu-' + this.cid;
-                this.keyBack = [constants.keyCodes.up, constants.keyCodes.left];
-                this.keyForward = [constants.keyCodes.down, constants.keyCodes.right];
-                this.keyClose = [constants.keyCodes.esc, constants.keyCodes.space];
-            },
+                    this.menuId = options.menuId || 'dropdown-menu-' + this.cid;
+                    this.keyBack = [constants.keyCodes.up, constants.keyCodes.left];
+                    this.keyForward = [constants.keyCodes.down, constants.keyCodes.right];
+                    this.keyClose = [constants.keyCodes.esc, constants.keyCodes.space];
+                },
 
-            className: function () {
-                return this.options.className;
-            },
+                className: function() {
+                    return this.options.className;
+                },
 
-            render: function () {
-                /**
+                render: function() {
+                    /**
                      * Set in the render function to prevent error when
                      * view is used with a pre-rendered DOM
                      */
-                this.model.set({ menuId: this.menuId });
+                    this.model.set({menuId: this.menuId});
 
-                this.$el.html(this.tpl(this.model.toJSON()));
-                this.$parent.replaceWith(this.$el);
-                this.postRender();
+                    this.$el.html(this.tpl(this.model.toJSON()));
+                    this.$parent.replaceWith(this.$el);
+                    this.postRender();
 
-                return this;
-            },
+                    return this;
+                },
 
-            postRender: function () {
-                this.$menu = this.$('.dropdown-menu');
-                this.$page = $(document);
-                this.$dropdownButton = this.$(this.dropdownButton);
-                this.$lastItem = this.$menu.find('li:last-child a');
-            },
+                postRender: function() {
+                    this.$menu = this.$('.dropdown-menu');
+                    this.$page = $(document);
+                    this.$dropdownButton = this.$(this.dropdownButton);
+                    this.$lastItem = this.$menu.find('li:last-child a');
+                },
 
-            /**
+                /**
                  * Function to track analytics.
                  *
                  * By default it doesn't do anything, to utilize please
@@ -115,173 +114,172 @@
                  * @param {object} event The event to be tracked.
                  * @returns {*} The event.
                  */
-            analyticsLinkClick: function (event) {
-                return event;
-            },
-
-            clickCloseDropdown: function (event, context) {
-                var $el = $(event.target) || $(document),
-                    $btn;
-
-                // When using edX Pattern Library icons the target
-                // is sometimes not the button.
-                if (!$el.hasClass(this.dropdownButton)) {
-                    // If there is a parent dropdown button that is the element to test
-                    $btn = $el.closest(this.dropdownButton);
-                    if ($btn.length > 0) {
-                        $el = $btn;
+                analyticsLinkClick: function(event) {
+                    return event;
+                },
+
+                clickCloseDropdown: function(event, context) {
+                    var $el = $(event.target) || $(document),
+                        $btn;
+
+                    // When using edX Pattern Library icons the target
+                    // is sometimes not the button.
+                    if (!$el.hasClass(this.dropdownButton)) {
+                        // If there is a parent dropdown button that is the element to test
+                        $btn = $el.closest(this.dropdownButton);
+                        if ($btn.length > 0) {
+                            $el = $btn;
+                        }
                     }
-                }
-
-                if (!$el.hasClass('button-more') && !$el.hasClass('has-dropdown')) {
-                    context.closeDropdownMenu();
-                }
-            },
 
-            clickOpenDropdown: function (event) {
-                event.preventDefault();
-                this.openMenu(this.$dropdownButton);
-            },
+                    if (!$el.hasClass('button-more') && !$el.hasClass('has-dropdown')) {
+                        context.closeDropdownMenu();
+                    }
+                },
 
-            closeDropdownMenu: function () {
-                var $open = this.$(this.menu);
+                clickOpenDropdown: function(event) {
+                    event.preventDefault();
+                    this.openMenu(this.$dropdownButton);
+                },
 
-                $open.removeClass('is-visible')
-                    .addClass('is-hidden');
+                closeDropdownMenu: function() {
+                    var $open = this.$(this.menu);
 
-                this.$dropdownButton
-                    .removeClass('is-active')
-                    .attr('aria-expanded', 'false');
-            },
+                    $open.removeClass('is-visible')
+                        .addClass('is-hidden');
 
-            focusFirstItem: function () {
-                this.$menu.find('.dropdown-item:first-child .action').focus();
-            },
+                    this.$dropdownButton
+                        .removeClass('is-active')
+                        .attr('aria-expanded', 'false');
+                },
 
-            focusLastItem: function () {
-                this.$lastItem.focus();
-            },
+                focusFirstItem: function() {
+                    this.$menu.find('.dropdown-item:first-child .action').focus();
+                },
 
-            handlerIsAction: function (key, $el) {
-                if (_.contains(this.keyForward, key)) {
-                    this.nextMenuItemLink($el);
-                } else if (_.contains(this.keyBack, key)) {
-                    this.previousMenuItemLink($el);
-                }
-            },
+                focusLastItem: function() {
+                    this.$lastItem.focus();
+                },
 
-            handlerIsButton: function (key, event) {
-                if (_.contains(this.keyForward, key)) {
-                    this.focusFirstItem();
-                    // if up arrow or left arrow key pressed or shift+tab
-                } else if (_.contains(this.keyBack, key) || (key === constants.keyCodes.tab && event.shiftKey)) {
-                    event.preventDefault();
-                    this.focusLastItem();
-                }
-            },
+                handlerIsAction: function(key, $el) {
+                    if (_.contains(this.keyForward, key)) {
+                        this.nextMenuItemLink($el);
+                    } else if (_.contains(this.keyBack, key)) {
+                        this.previousMenuItemLink($el);
+                    }
+                },
+
+                handlerIsButton: function(key, event) {
+                    if (_.contains(this.keyForward, key)) {
+                        this.focusFirstItem();
+                        // if up arrow or left arrow key pressed or shift+tab
+                    } else if (_.contains(this.keyBack, key) || (key === constants.keyCodes.tab && event.shiftKey)) {
+                        event.preventDefault();
+                        this.focusLastItem();
+                    }
+                },
 
-            handlerIsMenu: function (key) {
-                if (_.contains(this.keyForward, key)) {
-                    this.focusFirstItem();
-                } else if (_.contains(this.keyBack, key)) {
-                    this.$dropdownButton.focus();
-                }
-            },
-
-            handlerPageClicks: function (context) {
-                // Only want 1 event listener for click.dropdown
-                // on the page so unbind for instantiating
-                this.$page.off('click.dropdown');
-                this.$page.on('click.dropdown', function (event) {
-                    context.clickCloseDropdown(event, context);
-                });
-            },
-
-            nextMenuItemLink: function ($el) {
-                var items = this.$('.dropdown-menu').children('.dropdown-item').find('.action'),
-                    itemsCount = items.length - 1,
-                    index = items.index($el),
-                    next = index + 1;
-
-                if (index === itemsCount) {
-                    this.$dropdownButton.focus();
-                } else {
-                    items.eq(next).focus();
-                }
-            },
-
-            openMenu: function ($btn) {
-                // eslint-disable-next-line prefer-destructuring
-                var $menu = this.$menu;
-                if ($menu.hasClass('is-visible')) {
-                    this.closeDropdownMenu();
-                } else {
-                    $btn.addClass('is-active')
-                        .attr('aria-expanded', 'true');
-
-                    $menu.removeClass('is-hidden')
-                        .addClass('is-visible');
-
-                    $menu.focus();
-                    this.setOrientation();
-                    this.handlerPageClicks(this);
-                }
-            },
+                handlerIsMenu: function(key) {
+                    if (_.contains(this.keyForward, key)) {
+                        this.focusFirstItem();
+                    } else if (_.contains(this.keyBack, key)) {
+                        this.$dropdownButton.focus();
+                    }
+                },
+
+                handlerPageClicks: function(context) {
+                    // Only want 1 event listener for click.dropdown
+                    // on the page so unbind for instantiating
+                    this.$page.off('click.dropdown');
+                    this.$page.on('click.dropdown', function(event) {
+                        context.clickCloseDropdown(event, context);
+                    });
+                },
+
+                nextMenuItemLink: function($el) {
+                    var items = this.$('.dropdown-menu').children('.dropdown-item').find('.action'),
+                        itemsCount = items.length - 1,
+                        index = items.index($el),
+                        next = index + 1;
+
+                    if (index === itemsCount) {
+                        this.$dropdownButton.focus();
+                    } else {
+                        items.eq(next).focus();
+                    }
+                },
+
+                openMenu: function($btn) {
+                    var $menu = this.$menu;
+                    if ($menu.hasClass('is-visible')) {
+                        this.closeDropdownMenu();
+                    } else {
+                        $btn.addClass('is-active')
+                            .attr('aria-expanded', 'true');
+
+                        $menu.removeClass('is-hidden')
+                            .addClass('is-visible');
+
+                        $menu.focus();
+                        this.setOrientation();
+                        this.handlerPageClicks(this);
+                    }
+                },
 
-            previousMenuItemLink: function ($el) {
-                var items = this.$('.dropdown-menu').children('.dropdown-item').find('.action'),
-                    index = items.index($el),
-                    prev = index - 1;
+                previousMenuItemLink: function($el) {
+                    var items = this.$('.dropdown-menu').children('.dropdown-item').find('.action'),
+                        index = items.index($el),
+                        prev = index - 1;
 
-                if (index === 0) {
-                    this.$dropdownButton.focus();
-                } else {
-                    items.eq(prev).focus();
-                }
-            },
+                    if (index === 0) {
+                        this.$dropdownButton.focus();
+                    } else {
+                        items.eq(prev).focus();
+                    }
+                },
 
-            setOrientation: function () {
-                var midpoint = $(window).width() / 2,
-                    alignClass = (this.$dropdownButton.offset().left > midpoint) ? 'align-right' : 'align-left';
+                setOrientation: function() {
+                    var midpoint = $(window).width() / 2,
+                        alignClass = (this.$dropdownButton.offset().left > midpoint) ? 'align-right' : 'align-left';
 
-                this.$menu
-                    .removeClass('align-left align-right')
-                    .addClass(alignClass);
-            },
+                    this.$menu
+                        .removeClass('align-left align-right')
+                        .addClass(alignClass);
+                },
 
-            viewKeypress: function (event) {
-                var key = event.keyCode,
-                    $el = $(event.target);
+                viewKeypress: function(event) {
+                    var key = event.keyCode,
+                        $el = $(event.target);
 
-                if (_.contains(this.keyForward, key) || _.contains(this.keyBack, key)) {
-                    // Prevent default behavior if one of our trigger keys
-                    event.preventDefault();
-                }
+                    if (_.contains(this.keyForward, key) || _.contains(this.keyBack, key)) {
+                        // Prevent default behavior if one of our trigger keys
+                        event.preventDefault();
+                    }
 
-                if (key === constants.keyCodes.tab && !event.shiftKey && _.first($el) === _.first(this.$lastItem)) {
-                    event.preventDefault();
-                    this.$dropdownButton.focus();
-                } else if (_.contains(this.keyClose, key)) {
-                    this.closeDropdownMenu();
-                    this.$dropdownButton.focus();
-                } else if ($el.hasClass('action')) {
-                    // Key handlers for when a menu item has focus
-                    this.handlerIsAction(key, $el);
-                } else if ($el.hasClass('dropdown-menu')) {
-                    // Key handlers for when the menu itself has focus, before an item within it receives focus
-                    this.handlerIsMenu(key);
-                } else if ($el.hasClass('has-dropdown')) {
-                    // Key handlers for when the button that opens the menu has focus
-                    this.handlerIsButton(key, event);
+                    if (key === constants.keyCodes.tab && !event.shiftKey && _.first($el) === _.first(this.$lastItem)) {
+                        event.preventDefault();
+                        this.$dropdownButton.focus();
+                    } else if (_.contains(this.keyClose, key)) {
+                        this.closeDropdownMenu();
+                        this.$dropdownButton.focus();
+                    } else if ($el.hasClass('action')) {
+                        // Key handlers for when a menu item has focus
+                        this.handlerIsAction(key, $el);
+                    } else if ($el.hasClass('dropdown-menu')) {
+                        // Key handlers for when the menu itself has focus, before an item within it receives focus
+                        this.handlerIsMenu(key);
+                    } else if ($el.hasClass('has-dropdown')) {
+                        // Key handlers for when the button that opens the menu has focus
+                        this.handlerIsButton(key, event);
+                    }
                 }
-            },
-        });
+            });
 
-        return DropdownMenuView;
-    },
+            return DropdownMenuView;
+        }
     );
 }).call(
     this,
     // Use the default 'define' function if available, else use 'RequireJS.define'
-    typeof define === 'function' && define.amd ? define : RequireJS.define,
+    typeof define === 'function' && define.amd ? define : RequireJS.define
 );
diff --git a/src/js/dropdown-menu/specs/dropdown-menu-view-spec.js b/src/js/dropdown-menu/specs/dropdown-menu-view-spec.js
index b683c3a1..44a736fd 100644
--- a/src/js/dropdown-menu/specs/dropdown-menu-view-spec.js
+++ b/src/js/dropdown-menu/specs/dropdown-menu-view-spec.js
@@ -4,405 +4,405 @@ define([
     'backbone',
     '../dropdown-menu-view.js',
     '../../utils/constants.js',
-    'jquery.simulate',
+    'jquery.simulate'
 ],
-function ($, _, Backbone, DropdownMenuView, constants) {
-    'use strict';
-
-    describe('Dropdown Menu View', function () {
-        var view = {},
-            dropdownModel = new Backbone.Model(),
-            ExtendedDropdownMenuView,
-            singleKeyDown = function (key) {
-                $(document.activeElement).simulate('keydown', { keyCode: key });
-            },
-            focusTrapDown,
-            focusTrapUp,
-            menuIsClosed,
-            menuIsOpen,
-            openMenuTest,
-            closeMenuTest,
-            closeMenuOnPageClickTest,
-            closeOnKeypressTest,
-            timeoutInt = 100;
-
-        focusTrapDown = function (key, listLength) {
-            var $btn = view.$el.find('.js-dropdown-button');
-
-            $btn.click();
-
-            setTimeout(function () {
-                var i;
-
-                expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
-
-                for (i = 0; i < listLength; i += 1) {
+    function($, _, Backbone, DropdownMenuView, constants) {
+        'use strict';
+
+        describe('Dropdown Menu View', function() {
+            var view = {},
+                dropdownModel = new Backbone.Model(),
+                ExtendedDropdownMenuView,
+                singleKeyDown = function(key) {
+                    $(document.activeElement).simulate('keydown', {keyCode: key});
+                },
+                focusTrapDown,
+                focusTrapUp,
+                menuIsClosed,
+                menuIsOpen,
+                openMenuTest,
+                closeMenuTest,
+                closeMenuOnPageClickTest,
+                closeOnKeypressTest,
+                timeoutInt = 100;
+
+            focusTrapDown = function(key, listLength) {
+                var $btn = view.$el.find('.js-dropdown-button');
+
+                $btn.click();
+
+                setTimeout(function() {
+                    var i;
+
+                    expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
+
+                    for (i = 0; i < listLength; i += 1) {
+                        singleKeyDown(key);
+                    }
+                }, timeoutInt);
+
+                setTimeout(function() {
+                    expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
                     singleKeyDown(key);
-                }
-            }, timeoutInt);
-
-            setTimeout(function () {
-                expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
-                singleKeyDown(key);
-            }, timeoutInt * 2);
-
-            setTimeout(function () {
-                expect($(document.activeElement)).toHaveClass('js-dropdown-button');
-            }, timeoutInt * 3);
-
-            jasmine.clock().tick(timeoutInt + 1);
-            jasmine.clock().tick((timeoutInt * 2) + 1);
-            jasmine.clock().tick((timeoutInt * 3) + 1);
-        };
-
-        focusTrapUp = function (key) {
-            var $btn = view.$el.find('.js-dropdown-button');
-
-            $btn.click();
-
-            setTimeout(function () {
-                expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
-                singleKeyDown(key);
-            }, timeoutInt);
-
-            setTimeout(function () {
-                expect($(document.activeElement)).toHaveClass('js-dropdown-button');
-                singleKeyDown(key);
-            }, timeoutInt * 2);
-
-            setTimeout(function () {
-                var $active = $(document.activeElement),
-                    lastItem = _.last(view.model.get('items'));
-
-                expect($active).toHaveClass('action');
-                expect($active.attr('href')).toEqual(lastItem.url);
-            }, timeoutInt * 3);
-
-            jasmine.clock().tick(timeoutInt + 1);
-            jasmine.clock().tick((timeoutInt * 2) + 1);
-            jasmine.clock().tick((timeoutInt * 3) + 1);
-        };
-
-        menuIsClosed = function ($btn, $menu) {
-            expect($btn).not.toHaveClass('is-active');
-            expect($btn.attr('aria-expanded')).toEqual('false');
-            expect($menu).toHaveClass('is-hidden');
-        };
-
-        menuIsOpen = function ($btn, $menu) {
-            expect($btn).toHaveClass('is-active');
-            expect($btn.attr('aria-expanded')).toEqual('true');
-            expect($menu).not.toHaveClass('is-hidden');
-        };
-
-        openMenuTest = function () {
-            var $btn = view.$('.js-dropdown-button'),
-                $menu = view.$('ul.dropdown-menu');
-
-            menuIsClosed($btn, $menu);
-            $btn.click();
-
-            setTimeout(function () {
-                menuIsOpen($btn, $menu);
-            }, timeoutInt);
-
-            jasmine.clock().tick(timeoutInt + 1);
-        };
-
-        closeMenuTest = function () {
-            var $btn = view.$('.js-dropdown-button'),
-                $menu = view.$('ul.dropdown-menu');
-
-            menuIsClosed($btn, $menu);
-            $btn.click();
-
-            setTimeout(function () {
-                menuIsOpen($btn, $menu);
+                }, timeoutInt * 2);
+
+                setTimeout(function() {
+                    expect($(document.activeElement)).toHaveClass('js-dropdown-button');
+                }, timeoutInt * 3);
+
+                jasmine.clock().tick(timeoutInt + 1);
+                jasmine.clock().tick((timeoutInt * 2) + 1);
+                jasmine.clock().tick((timeoutInt * 3) + 1);
+            };
+
+            focusTrapUp = function(key) {
+                var $btn = view.$el.find('.js-dropdown-button');
+
                 $btn.click();
-            }, timeoutInt);
 
-            setTimeout(function () {
+                setTimeout(function() {
+                    expect($(document.activeElement)).not.toHaveClass('js-dropdown-button');
+                    singleKeyDown(key);
+                }, timeoutInt);
+
+                setTimeout(function() {
+                    expect($(document.activeElement)).toHaveClass('js-dropdown-button');
+                    singleKeyDown(key);
+                }, timeoutInt * 2);
+
+                setTimeout(function() {
+                    var $active = $(document.activeElement),
+                        lastItem = _.last(view.model.get('items'));
+
+                    expect($active).toHaveClass('action');
+                    expect($active.attr('href')).toEqual(lastItem.url);
+                }, timeoutInt * 3);
+
+                jasmine.clock().tick(timeoutInt + 1);
+                jasmine.clock().tick((timeoutInt * 2) + 1);
+                jasmine.clock().tick((timeoutInt * 3) + 1);
+            };
+
+            menuIsClosed = function($btn, $menu) {
+                expect($btn).not.toHaveClass('is-active');
+                expect($btn.attr('aria-expanded')).toEqual('false');
+                expect($menu).toHaveClass('is-hidden');
+            };
+
+            menuIsOpen = function($btn, $menu) {
+                expect($btn).toHaveClass('is-active');
+                expect($btn.attr('aria-expanded')).toEqual('true');
+                expect($menu).not.toHaveClass('is-hidden');
+            };
+
+            openMenuTest = function() {
+                var $btn = view.$('.js-dropdown-button'),
+                    $menu = view.$('ul.dropdown-menu');
+
+                menuIsClosed($btn, $menu);
+                $btn.click();
+
+                setTimeout(function() {
+                    menuIsOpen($btn, $menu);
+                }, timeoutInt);
+
+                jasmine.clock().tick(timeoutInt + 1);
+            };
+
+            closeMenuTest = function() {
+                var $btn = view.$('.js-dropdown-button'),
+                    $menu = view.$('ul.dropdown-menu');
+
                 menuIsClosed($btn, $menu);
-            }, timeoutInt * 2);
+                $btn.click();
 
-            jasmine.clock().tick(timeoutInt + 1);
-            jasmine.clock().tick((timeoutInt * 2) + 1);
-        };
+                setTimeout(function() {
+                    menuIsOpen($btn, $menu);
+                    $btn.click();
+                }, timeoutInt);
 
-        closeMenuOnPageClickTest = function () {
-            var $btn = view.$('.js-dropdown-button'),
-                $menu = view.$('ul.dropdown-menu');
+                setTimeout(function() {
+                    menuIsClosed($btn, $menu);
+                }, timeoutInt * 2);
 
-            menuIsClosed($btn, $menu);
-            $btn.click();
+                jasmine.clock().tick(timeoutInt + 1);
+                jasmine.clock().tick((timeoutInt * 2) + 1);
+            };
 
-            setTimeout(function () {
-                menuIsOpen($btn, $menu);
-                $(document).click();
-            }, timeoutInt);
+            closeMenuOnPageClickTest = function() {
+                var $btn = view.$('.js-dropdown-button'),
+                    $menu = view.$('ul.dropdown-menu');
 
-            setTimeout(function () {
                 menuIsClosed($btn, $menu);
-            }, timeoutInt * 2);
+                $btn.click();
 
-            jasmine.clock().tick(timeoutInt + 1);
-            jasmine.clock().tick((timeoutInt * 2) + 1);
-        };
+                setTimeout(function() {
+                    menuIsOpen($btn, $menu);
+                    $(document).click();
+                }, timeoutInt);
 
-        closeOnKeypressTest = function (key) {
-            var $btn = view.$('.js-dropdown-button'),
-                $menu = view.$('ul.dropdown-menu');
+                setTimeout(function() {
+                    menuIsClosed($btn, $menu);
+                }, timeoutInt * 2);
 
-            menuIsClosed($btn, $menu);
-            $btn.click();
+                jasmine.clock().tick(timeoutInt + 1);
+                jasmine.clock().tick((timeoutInt * 2) + 1);
+            };
 
-            setTimeout(function () {
-                menuIsOpen($btn, $menu);
-                singleKeyDown(key);
-            }, timeoutInt);
+            closeOnKeypressTest = function(key) {
+                var $btn = view.$('.js-dropdown-button'),
+                    $menu = view.$('ul.dropdown-menu');
 
-            setTimeout(function () {
                 menuIsClosed($btn, $menu);
-            }, timeoutInt * 2);
+                $btn.click();
+
+                setTimeout(function() {
+                    menuIsOpen($btn, $menu);
+                    singleKeyDown(key);
+                }, timeoutInt);
+
+                setTimeout(function() {
+                    menuIsClosed($btn, $menu);
+                }, timeoutInt * 2);
 
-            jasmine.clock().tick(timeoutInt + 1);
-            jasmine.clock().tick((timeoutInt * 2) + 1);
-        };
+                jasmine.clock().tick(timeoutInt + 1);
+                jasmine.clock().tick((timeoutInt * 2) + 1);
+            };
 
-        beforeEach(function () {
-            // Extend the view to add analytics for testing
-            ExtendedDropdownMenuView = DropdownMenuView.extend({
-                analyticsLinkClick: function (event) {
-                    var $link = $(event.target),
-                        label = $link.hasClass('menu-title') ? 'Dashboard' : $link.html().trim();
+            beforeEach(function() {
+                // Extend the view to add analytics for testing
+                ExtendedDropdownMenuView = DropdownMenuView.extend({
+                    analyticsLinkClick: function(event) {
+                        var $link = $(event.target),
+                            label = $link.hasClass('menu-title') ? 'Dashboard' : $link.html().trim();
 
-                    /**
+                        /**
                          *  Add your own analytics tracking here
                          *  for example:
                          */
-                    window.analytics.track('user_dropdown.clicked', {
-                        category: 'navigation',
-                        label: label,
-                        link: $link.attr('href'),
-                    });
-                },
-            });
+                        window.analytics.track('user_dropdown.clicked', {
+                            category: 'navigation',
+                            label: label,
+                            link: $link.attr('href')
+                        });
+                    }
+                });
 
-            // Set the DOM
-            setFixtures('<div class="js-user-cta"></div>');
+                // Set the DOM
+                setFixtures('<div class="js-user-cta"></div>');
 
-            dropdownModel.set({
-                main: {
-                    text: 'username',
-                    url: 'dashboard',
-                },
-                button: {
-                    label: 'User options dropdown',
-                },
-                items: [
-                    {
-                        text: 'Dashboard',
-                        url: 'dashboard',
-                    }, {
-                        text: 'Account',
-                        url: 'account_settings',
-                    }, {
-                        text: 'Profile',
-                        url: 'learner_profile',
-                    }, {
-                        text: 'Sign Out',
-                        url: 'logout',
+                dropdownModel.set({
+                    main: {
+                        text: 'username',
+                        url: 'dashboard'
                     },
-                ],
-            });
-        });
-
-        afterEach(function () {
-            view.remove();
-            jasmine.clock().uninstall();
-        });
-
-        describe('Default icon usage', function () {
-            beforeEach(function () {
-                view = new ExtendedDropdownMenuView({
-                    className: 'wrapper-more-actions user-menu logged-in',
-                    menuId: 'edx-user-menu',
-                    model: dropdownModel,
-                    parent: '.js-user-cta',
-                }).render();
-
-                window.analytics = jasmine.createSpyObj('analytics', ['track', 'page', 'trackLink']);
-
-                jasmine.clock().install();
+                    button: {
+                        label: 'User options dropdown'
+                    },
+                    items: [
+                        {
+                            text: 'Dashboard',
+                            url: 'dashboard'
+                        }, {
+                            text: 'Account',
+                            url: 'account_settings'
+                        }, {
+                            text: 'Profile',
+                            url: 'learner_profile'
+                        }, {
+                            text: 'Sign Out',
+                            url: 'logout'
+                        }
+                    ]
+                });
             });
 
-            afterEach(function () {
+            afterEach(function() {
                 view.remove();
                 jasmine.clock().uninstall();
             });
 
-            it('should exist', function () {
-                expect(view).toBeDefined();
-            });
+            describe('Default icon usage', function() {
+                beforeEach(function() {
+                    view = new ExtendedDropdownMenuView({
+                        className: 'wrapper-more-actions user-menu logged-in',
+                        menuId: 'edx-user-menu',
+                        model: dropdownModel,
+                        parent: '.js-user-cta'
+                    }).render();
 
-            it('should open the user menu on click of the button', openMenuTest);
+                    window.analytics = jasmine.createSpyObj('analytics', ['track', 'page', 'trackLink']);
 
-            it('should close the user menu on click of the button', closeMenuTest);
+                    jasmine.clock().install();
+                });
 
-            it('should close the user menu on keypress of the esc key', function () {
-                closeOnKeypressTest(constants.keyCodes.esc);
-            });
+                afterEach(function() {
+                    view.remove();
+                    jasmine.clock().uninstall();
+                });
 
-            it('should close the user menu on keypress of the space bar', function () {
-                closeOnKeypressTest(constants.keyCodes.space);
-            });
+                it('should exist', function() {
+                    expect(view).toBeDefined();
+                });
 
-            it('should return to the button after pressing ↓ while at bottom of dropdown menu', function () {
-                focusTrapDown(constants.keyCodes.down, 4);
-            });
+                it('should open the user menu on click of the button', openMenuTest);
 
-            it('should return to the button after pressing → while at bottom of dropdown menu', function () {
-                focusTrapDown(constants.keyCodes.right, 4);
-            });
+                it('should close the user menu on click of the button', closeMenuTest);
 
-            it('should return to the bottom of dropdown menu after pressing ↑ while on button', function () {
-                focusTrapUp(constants.keyCodes.up);
-            });
+                it('should close the user menu on keypress of the esc key', function() {
+                    closeOnKeypressTest(constants.keyCodes.esc);
+                });
 
-            it('should return to the bottom of dropdown menu after pressing ← while on button', function () {
-                focusTrapUp(constants.keyCodes.left);
-            });
+                it('should close the user menu on keypress of the space bar', function() {
+                    closeOnKeypressTest(constants.keyCodes.space);
+                });
 
-            it('should close the user menu on page click', closeMenuOnPageClickTest);
+                it('should return to the button after pressing ↓ while at bottom of dropdown menu', function() {
+                    focusTrapDown(constants.keyCodes.down, 4);
+                });
 
-            it('should add a screenreader label to the user link if provided', function () {
-                var $srLabel = view.$el.find('.menu-title .sr-only'),
-                    srLabelText = 'Dashboard for:';
+                it('should return to the button after pressing → while at bottom of dropdown menu', function() {
+                    focusTrapDown(constants.keyCodes.right, 4);
+                });
 
-                expect($srLabel.length).toEqual(0);
+                it('should return to the bottom of dropdown menu after pressing ↑ while on button', function() {
+                    focusTrapUp(constants.keyCodes.up);
+                });
 
-                view.model.set({
-                    main: {
-                        text: 'username',
-                        screenreader_label: srLabelText,
-                        url: 'dashboard',
-                    },
+                it('should return to the bottom of dropdown menu after pressing ← while on button', function() {
+                    focusTrapUp(constants.keyCodes.left);
                 });
-                view.render();
-                $srLabel = view.$el.find('.menu-title .sr-only');
-                expect($srLabel.length).toEqual(1);
-                expect($srLabel.html().trim()).toEqual(srLabelText);
-            });
 
-            it('should add a user image to the user link if provided', function () {
-                var $img = view.$el.find('.menu-title .menu-image'),
-                    imgSrc = 'http://placehold.it/350x150';
-                expect($img.length).toEqual(0);
+                it('should close the user menu on page click', closeMenuOnPageClickTest);
 
-                view.model.set({
-                    main: {
-                        text: 'username',
-                        image: imgSrc,
-                        url: 'dashboard',
-                    },
+                it('should add a screenreader label to the user link if provided', function() {
+                    var $srLabel = view.$el.find('.menu-title .sr-only'),
+                        srLabelText = 'Dashboard for:';
+
+                    expect($srLabel.length).toEqual(0);
+
+                    view.model.set({
+                        main: {
+                            text: 'username',
+                            screenreader_label: srLabelText,
+                            url: 'dashboard'
+                        }
+                    });
+                    view.render();
+                    $srLabel = view.$el.find('.menu-title .sr-only');
+                    expect($srLabel.length).toEqual(1);
+                    expect($srLabel.html().trim()).toEqual(srLabelText);
                 });
-                view.render();
-                $img = view.$el.find('.menu-title .menu-image');
-                expect($img.length).toEqual(1);
-                expect($img.attr('src')).toEqual(imgSrc);
-            });
 
-            it('should open track analytics for user title clicks', function () {
-                var $userTitle = view.$el.find('.menu-title'),
-                    analyticsData = {
-                        category: 'navigation',
-                        label: 'Dashboard',
-                        link: 'dashboard',
-                    };
+                it('should add a user image to the user link if provided', function() {
+                    var $img = view.$el.find('.menu-title .menu-image'),
+                        imgSrc = 'http://placehold.it/350x150';
+                    expect($img.length).toEqual(0);
+
+                    view.model.set({
+                        main: {
+                            text: 'username',
+                            image: imgSrc,
+                            url: 'dashboard'
+                        }
+                    });
+                    view.render();
+                    $img = view.$el.find('.menu-title .menu-image');
+                    expect($img.length).toEqual(1);
+                    expect($img.attr('src')).toEqual(imgSrc);
+                });
 
-                $userTitle.click();
+                it('should open track analytics for user title clicks', function() {
+                    var $userTitle = view.$el.find('.menu-title'),
+                        analyticsData = {
+                            category: 'navigation',
+                            label: 'Dashboard',
+                            link: 'dashboard'
+                        };
 
-                setTimeout(function () {
-                    expect(window.analytics.track).toHaveBeenCalledWith('user_dropdown.clicked', analyticsData);
-                }, timeoutInt);
+                    $userTitle.click();
 
-                jasmine.clock().tick(timeoutInt + 1);
-            });
+                    setTimeout(function() {
+                        expect(window.analytics.track).toHaveBeenCalledWith('user_dropdown.clicked', analyticsData);
+                    }, timeoutInt);
 
-            it('should open track analytics for user menu link clicks', function () {
-                var $userTitle = view.$el.find('.dropdown-item').last().find('a'),
-                    analyticsData = {
-                        category: 'navigation',
-                        label: 'Sign Out',
-                        link: 'logout',
-                    };
+                    jasmine.clock().tick(timeoutInt + 1);
+                });
 
-                $userTitle.click();
+                it('should open track analytics for user menu link clicks', function() {
+                    var $userTitle = view.$el.find('.dropdown-item').last().find('a'),
+                        analyticsData = {
+                            category: 'navigation',
+                            label: 'Sign Out',
+                            link: 'logout'
+                        };
 
-                setTimeout(function () {
-                    expect(window.analytics.track).toHaveBeenCalledWith('user_dropdown.clicked', analyticsData);
-                }, timeoutInt);
+                    $userTitle.click();
 
-                jasmine.clock().tick(timeoutInt + 1);
-            });
-        });
+                    setTimeout(function() {
+                        expect(window.analytics.track).toHaveBeenCalledWith('user_dropdown.clicked', analyticsData);
+                    }, timeoutInt);
 
-        describe('Pattern Library icon usage', function () {
-            beforeEach(function () {
-                dropdownModel.set({
-                    button: {
-                        icon: 'fa fa-angle-down',
-                        label: 'User options dropdown',
-                    },
+                    jasmine.clock().tick(timeoutInt + 1);
                 });
-                view = new ExtendedDropdownMenuView({
-                    className: 'wrapper-more-actions user-menu logged-in',
-                    menuId: 'edx-user-menu',
-                    model: dropdownModel,
-                    parent: '.js-user-cta',
-                }).render();
+            });
 
-                window.analytics = jasmine.createSpyObj('analytics', ['track', 'page', 'trackLink']);
+            describe('Pattern Library icon usage', function() {
+                beforeEach(function() {
+                    dropdownModel.set({
+                        button: {
+                            icon: 'fa fa-angle-down',
+                            label: 'User options dropdown'
+                        }
+                    });
+                    view = new ExtendedDropdownMenuView({
+                        className: 'wrapper-more-actions user-menu logged-in',
+                        menuId: 'edx-user-menu',
+                        model: dropdownModel,
+                        parent: '.js-user-cta'
+                    }).render();
 
-                jasmine.clock().install();
-            });
+                    window.analytics = jasmine.createSpyObj('analytics', ['track', 'page', 'trackLink']);
 
-            afterEach(function () {
-                view.remove();
-                jasmine.clock().uninstall();
-            });
+                    jasmine.clock().install();
+                });
 
-            it('should exist', function () {
-                expect(view).toBeDefined();
-            });
+                afterEach(function() {
+                    view.remove();
+                    jasmine.clock().uninstall();
+                });
 
-            it('should open the user menu on click of the button', openMenuTest);
+                it('should exist', function() {
+                    expect(view).toBeDefined();
+                });
 
-            it('should close the user menu on click of the button', closeMenuTest);
+                it('should open the user menu on click of the button', openMenuTest);
 
-            it('should close the user menu on page click', closeMenuOnPageClickTest);
+                it('should close the user menu on click of the button', closeMenuTest);
 
-            it('should toggle the menu on icon click', function () {
-                var $btn = view.$('.js-dropdown-button'),
-                    $icon = $btn.find('.icon'),
-                    $menu = view.$('ul.dropdown-menu');
+                it('should close the user menu on page click', closeMenuOnPageClickTest);
 
-                menuIsClosed($btn, $menu);
-                $icon.click();
+                it('should toggle the menu on icon click', function() {
+                    var $btn = view.$('.js-dropdown-button'),
+                        $icon = $btn.find('.icon'),
+                        $menu = view.$('ul.dropdown-menu');
 
-                setTimeout(function () {
-                    menuIsOpen($btn, $menu);
+                    menuIsClosed($btn, $menu);
                     $icon.click();
-                }, timeoutInt);
 
-                setTimeout(function () {
-                    menuIsClosed($btn, $menu);
-                }, timeoutInt * 2);
+                    setTimeout(function() {
+                        menuIsOpen($btn, $menu);
+                        $icon.click();
+                    }, timeoutInt);
 
-                jasmine.clock().tick(timeoutInt + 1);
-                jasmine.clock().tick((timeoutInt * 2) + 1);
+                    setTimeout(function() {
+                        menuIsClosed($btn, $menu);
+                    }, timeoutInt * 2);
+
+                    jasmine.clock().tick(timeoutInt + 1);
+                    jasmine.clock().tick((timeoutInt * 2) + 1);
+                });
             });
         });
-    });
-},
+    }
 );
diff --git a/src/js/pagination/paging-collection.js b/src/js/pagination/paging-collection.js
index 52574ee4..3849f544 100644
--- a/src/js/pagination/paging-collection.js
+++ b/src/js/pagination/paging-collection.js
@@ -25,10 +25,10 @@
  *
  * @module PagingCollection
  */
-(function (define) {
+(function(define) {
     'use strict';
 
-    define(['jquery', 'underscore', 'backbone.paginator'], function ($, _, PageableCollection) {
+    define(['jquery', 'underscore', 'backbone.paginator'], function($, _, PageableCollection) {
         var PagingCollection = PageableCollection.extend({
             mode: 'server',
 
@@ -41,7 +41,7 @@
             state: {
                 firstPage: 1,
                 pageSize: 10,
-                sortKey: null,
+                sortKey: null
             },
 
             queryParams: {
@@ -50,16 +50,16 @@
                 totalRecords: 'count',
                 totalPages: 'num_pages',
                 sortKey: 'order_by',
-                order: 'sort_order',
+                order: 'sort_order'
             },
 
-            constructor: function (models, options) {
+            constructor: function(models, options) {
                 this.state = _.extend({}, PagingCollection.prototype.state, this.state);
                 this.queryParams = _.extend({}, PagingCollection.prototype.queryParams, this.queryParams);
                 PageableCollection.prototype.constructor.call(this, models, options);
             },
 
-            initialize: function (models, options) {
+            initialize: function(models, options) {
                 // These must be initialized in the constructor
                 // because otherwise all PagingCollections would point
                 // to the same object references for sortableFields
@@ -69,7 +69,7 @@
                 PageableCollection.prototype.initialize.call(this, models, options);
             },
 
-            parse: function (response, options) {
+            parse: function(response, options) {
                 // PageableCollection expects the response to be an
                 // array of two elements - the server-side state
                 // metadata (page, size, etc.), and the array of
@@ -87,7 +87,7 @@
              *
              * @returns {integer} The current page number.
              */
-            getPageNumber: function () {
+            getPageNumber: function() {
                 return this.state.currentPage + (1 - this.state.firstPage);
             },
 
@@ -97,7 +97,7 @@
              *
              * @returns {integer} Total number of pages.
              */
-            getTotalPages: function () {
+            getTotalPages: function() {
                 return this.state.totalPages;
             },
 
@@ -106,7 +106,7 @@
              *
              * @returns {integer} Total number of records.
              */
-            getTotalRecords: function () {
+            getTotalRecords: function() {
                 return this.state.totalRecords;
             },
 
@@ -115,7 +115,7 @@
              *
              * @returns {integer} Number of records per page.
              */
-            getPageSize: function () {
+            getPageSize: function() {
                 return this.state.pageSize;
             },
 
@@ -129,20 +129,20 @@
              *
              * @param page {integer} one-indexed page to change to.
              */
-            setPage: function (page) {
+            setPage: function(page) {
                 var oldPage = this.state.currentPage,
                     self = this,
                     deferred = $.Deferred();
-                this.getPage(page - (1 - this.state.firstPage), { reset: true }).then(
-                    function () {
+                this.getPage(page - (1 - this.state.firstPage), {reset: true}).then(
+                    function() {
                         self.isStale = false;
                         self.trigger('page_changed');
                         deferred.resolve();
                     },
-                    function () {
+                    function() {
                         self.state.currentPage = oldPage;
                         deferred.fail();
-                    },
+                    }
                 );
                 return deferred.promise();
             },
@@ -153,11 +153,11 @@
              * @returns {promise} Returns a promise representing the
              *     refresh.
              */
-            refresh: function () {
+            refresh: function() {
                 var deferred = $.Deferred();
                 if (this.isStale) {
                     this.setPage(1)
-                        .done(function () {
+                        .done(function() {
                             deferred.resolve();
                         });
                 } else {
@@ -172,7 +172,7 @@
              *
              * @returns {boolean} Returns true if the collection has a next page.
              */
-            hasNextPage: function () {
+            hasNextPage: function() {
                 return this.getPageNumber() < this.state.totalPages;
             },
 
@@ -182,14 +182,14 @@
              *
              * @returns {boolean} Returns true if the collection has a previous page.
              */
-            hasPreviousPage: function () {
+            hasPreviousPage: function() {
                 return this.getPageNumber() > 1;
             },
 
             /**
              * Moves the collection to the next page if it exists.
              */
-            nextPage: function () {
+            nextPage: function() {
                 if (this.hasNextPage()) {
                     this.setPage(this.getPageNumber() + 1);
                 }
@@ -198,7 +198,7 @@
             /**
              * Moves the collection to the previous page if it exists.
              */
-            previousPage: function () {
+            previousPage: function() {
                 if (this.hasPreviousPage()) {
                     this.setPage(this.getPageNumber() - 1);
                 }
@@ -212,7 +212,7 @@
              * @param displayName {string} name of the field to display to the
              *     user
              */
-            registerSortableField: function (fieldName, displayName) {
+            registerSortableField: function(fieldName, displayName) {
                 this.addField(this.sortableFields, fieldName, displayName);
             },
 
@@ -224,7 +224,7 @@
              * @param displayName {string} name of the field to display to the
              *     user
              */
-            registerFilterableField: function (fieldName, displayName) {
+            registerFilterableField: function(fieldName, displayName) {
                 this.addField(this.filterableFields, fieldName, displayName);
             },
 
@@ -236,10 +236,10 @@
              * @param displayName {string} name of the field to display to the
              *     user
              */
-            addField: function (fields, fieldName, displayName) {
+            addField: function(fields, fieldName, displayName) {
                 var newField = {};
                 newField[fieldName] = {
-                    displayName: displayName,
+                    displayName: displayName
                 };
                 _.extend(fields, newField);
             },
@@ -250,11 +250,12 @@
              *
              * @returns {string} The display name of the sort field.
              */
-            sortDisplayName: function () {
+            sortDisplayName: function() {
                 if (this.state.sortKey) {
                     return this.sortableFields[this.state.sortKey].displayName;
+                } else {
+                    return '';
                 }
-                return '';
             },
 
             /**
@@ -264,11 +265,12 @@
              *     filterable field
              * @returns {string} The display name of the specified filterable field.
              */
-            filterDisplayName: function (fieldName) {
+            filterDisplayName: function(fieldName) {
                 if (!_.isUndefined(this.filterableFields[fieldName])) {
                     return this.filterableFields[fieldName].displayName;
+                } else {
+                    return '';
                 }
-                return '';
             },
 
             /**
@@ -279,7 +281,7 @@
              * @param toggleDirection {boolean} if true, the sort direction is
              *     toggled if the given field was already set
              */
-            setSortField: function (fieldName, toggleDirection) {
+            setSortField: function(fieldName, toggleDirection) {
                 var direction = toggleDirection ? 0 - this.state.order : this.state.order;
                 if (fieldName !== this.state.sortKey || toggleDirection) {
                     this.setSorting(fieldName, direction);
@@ -297,10 +299,10 @@
              *
              * @returns {string} Returns the direction of the current sort.
              */
-            sortDirection: function () {
-                return (this.state.order === -1)
-                    ? PagingCollection.SortDirection.ASCENDING
-                    : PagingCollection.SortDirection.DESCENDING;
+            sortDirection: function() {
+                return (this.state.order === -1) ?
+                    PagingCollection.SortDirection.ASCENDING :
+                    PagingCollection.SortDirection.DESCENDING;
             },
 
             /**
@@ -311,7 +313,7 @@
              * @param direction {string} either ASCENDING or DESCENDING from
              *     PagingCollection.SortDirection.
              */
-            setSortDirection: function (direction) {
+            setSortDirection: function(direction) {
                 var currentOrder = this.state.order,
                     newOrder = currentOrder;
                 if (direction === PagingCollection.SortDirection.ASCENDING) {
@@ -328,7 +330,7 @@
             /**
              * Flips the sort order.
              */
-            flipSortDirection: function () {
+            flipSortDirection: function() {
                 this.setSorting(this.state.sortKey, 0 - this.state.order);
                 this.isStale = true;
             },
@@ -341,9 +343,9 @@
              *     filterable field
              * @return {boolean} Returns true if this collection has the specified field.
              */
-            hasRegisteredFilterField: function (fieldName) {
-                return _.has(this.filterableFields, fieldName)
-                    && !_.isUndefined(this.filterableFields[fieldName].displayName);
+            hasRegisteredFilterField: function(fieldName) {
+                return _.has(this.filterableFields, fieldName) &&
+                    !_.isUndefined(this.filterableFields[fieldName].displayName);
             },
 
             /**
@@ -353,7 +355,7 @@
              *     filterable field
              * @return {boolean} Returns true if this collection has set the specified field.
              */
-            hasSetFilterField: function (fieldName) {
+            hasSetFilterField: function(fieldName) {
                 return _.has(this.filterableFields, fieldName) && !_.isNull(this.filterableFields[fieldName].value);
             },
 
@@ -365,12 +367,12 @@
              * @returns {Object} An object mapping the names of currently active
              * filter fields to their values.
              */
-            getActiveFilterFields: function (includeSearch) {
+            getActiveFilterFields: function(includeSearch) {
                 var activeFilterFields = _.chain(this.filterableFields)
-                    .pick(function (fieldData) {
+                    .pick(function(fieldData) {
                         return !_.isNull(fieldData.value) && !_.isUndefined(fieldData.value);
                     })
-                    .mapObject(function (data) {
+                    .mapObject(function(data) {
                         return data.value;
                     });
                 if (!includeSearch) {
@@ -385,7 +387,7 @@
              * @returns {String} the current value of the requested filter
              *     field.  null means that the filter field is not active.
              */
-            getFilterFieldValue: function (filterFieldName) {
+            getFilterFieldValue: function(filterFieldName) {
                 var val = this.getActiveFilterFields(true)[filterFieldName];
                 return (_.isNull(val) || _.isUndefined(val)) ? null : val;
             },
@@ -398,7 +400,7 @@
              *     filterable field
              * @param value {*} value for the filterable field
              */
-            setFilterField: function (fieldName, value) {
+            setFilterField: function(fieldName, value) {
                 var queryStringValue;
                 if (!this.hasRegisteredFilterField(fieldName)) {
                     this.registerFilterableField(fieldName, '');
@@ -409,7 +411,7 @@
                 } else {
                     queryStringValue = value;
                 }
-                this.queryParams[fieldName] = function () {
+                this.queryParams[fieldName] = function() {
                     return queryStringValue || null;
                 };
                 this.isStale = true;
@@ -422,7 +424,7 @@
              * @param fieldName {string} querystring parameter name for the
              *     filterable field
              */
-            unsetFilterField: function (fieldName) {
+            unsetFilterField: function(fieldName) {
                 if (this.hasSetFilterField(fieldName)) {
                     this.setFilterField(fieldName, null);
                 }
@@ -432,7 +434,7 @@
              * Unsets all of the collections filterable fields and marks
              * the collection as stale.
              */
-            unsetAllFilterFields: function () {
+            unsetAllFilterFields: function() {
                 _.each(_.keys(this.filterableFields), _.bind(this.unsetFilterField, this));
             },
 
@@ -442,7 +444,7 @@
              * @returns {String} the current value of the search string.  null
              * or undefined means that the filter field is not active.
              */
-            getSearchString: function () {
+            getSearchString: function() {
                 return this.getFilterFieldValue(PagingCollection.DefaultSearchKey);
             },
 
@@ -451,7 +453,7 @@
              *
              * @returns {bool} - whether a search is currently applied.
              */
-            hasActiveSearch: function () {
+            hasActiveSearch: function() {
                 var currentSearch = this.getSearchString();
                 return !_.isNull(currentSearch) && currentSearch !== '';
             },
@@ -463,7 +465,7 @@
              * @param searchString {string} A string to search on, or null if no
              *     search is to be applied.
              */
-            setSearchString: function (searchString) {
+            setSearchString: function(searchString) {
                 if (searchString !== this.getSearchString()) {
                     this.setFilterField(PagingCollection.DefaultSearchKey, searchString);
                 }
@@ -473,15 +475,15 @@
              * Unsets the string to use for a text search and marks the
              * collection as stale.
              */
-            unsetSearchString: function () {
+            unsetSearchString: function() {
                 this.unsetFilterField(PagingCollection.DefaultSearchKey);
-            },
+            }
         }, {
             DefaultSearchKey: 'text_search',
             SortDirection: {
                 ASCENDING: 'asc',
-                DESCENDING: 'desc',
-            },
+                DESCENDING: 'desc'
+            }
         });
 
         return PagingCollection;
@@ -489,5 +491,5 @@
 }).call(
     this,
     // Use the default 'define' function if available, else use 'RequireJS.define'
-    typeof define === 'function' && define.amd ? define : RequireJS.define,
+    typeof define === 'function' && define.amd ? define : RequireJS.define
 );
diff --git a/src/js/pagination/specs/paging-collection-spec.js b/src/js/pagination/specs/paging-collection-spec.js
index 4dc70755..542f85eb 100644
--- a/src/js/pagination/specs/paging-collection-spec.js
+++ b/src/js/pagination/specs/paging-collection-spec.js
@@ -4,460 +4,460 @@ define(['jquery',
     'URI',
     '../paging-collection.js',
     '../../utils/spec-helpers/ajax-helpers.js',
-    '../../utils/spec-helpers/spec-helpers.js',
+    '../../utils/spec-helpers/spec-helpers.js'
 ],
-function ($, Backbone, _, URI, PagingCollection, AjaxHelpers, SpecHelpers) {
-    'use strict';
-
-    describe('PagingCollection', function () {
-        var collection,
-            server = {
-                isZeroIndexed: false,
-                count: 43,
-                respond: function (requests) {
-                    var request = AjaxHelpers.currentRequest(requests),
-                        params = (new URI(request.url)).query(true),
-                        page = parseInt(params.page, 10),
-                        pageSize = parseInt(params.page_size, 10),
-                        pageCount = Math.ceil(this.count / pageSize),
-                        zeroPage;
-
-                    // Make zeroPage consistently start at zero for ease of calculation
-                    zeroPage = page - (this.isZeroIndexed ? 0 : 1);
-                    if (zeroPage < 0 || zeroPage > pageCount) {
-                        AjaxHelpers.respondWithError(requests, 404);
-                    } else {
-                        AjaxHelpers.respondWithJson(requests, {
-                            count: this.count,
-                            current_page: page,
-                            num_pages: pageCount,
-                            start: zeroPage * pageSize,
-                            results: [],
-                        });
+    function($, Backbone, _, URI, PagingCollection, AjaxHelpers, SpecHelpers) {
+        'use strict';
+
+        describe('PagingCollection', function() {
+            var collection,
+                server = {
+                    isZeroIndexed: false,
+                    count: 43,
+                    respond: function(requests) {
+                        var request = AjaxHelpers.currentRequest(requests),
+                            params = (new URI(request.url)).query(true),
+                            page = parseInt(params.page, 10),
+                            pageSize = parseInt(params.page_size, 10),
+                            pageCount = Math.ceil(this.count / pageSize),
+                            zeroPage;
+
+                        // Make zeroPage consistently start at zero for ease of calculation
+                        zeroPage = page - (this.isZeroIndexed ? 0 : 1);
+                        if (zeroPage < 0 || zeroPage > pageCount) {
+                            AjaxHelpers.respondWithError(requests, 404);
+                        } else {
+                            AjaxHelpers.respondWithJson(requests, {
+                                count: this.count,
+                                current_page: page,
+                                num_pages: pageCount,
+                                start: zeroPage * pageSize,
+                                results: []
+                            });
+                        }
                     }
                 },
-            };
-        var getUrlParams = function (request) {
-            return (new URI(request.url)).query(true);
-        };
-        var assertQueryParams = function (requests, params) {
-            var request = AjaxHelpers.currentRequest(requests),
-                urlParams = getUrlParams(request);
-            _.each(params, function (value, key) {
-                expect(urlParams[key]).toBe(value);
+                getUrlParams = function(request) {
+                    return (new URI(request.url)).query(true);
+                },
+                assertQueryParams = function(requests, params) {
+                    var request = AjaxHelpers.currentRequest(requests),
+                        urlParams = getUrlParams(request);
+                    _.each(params, function(value, key) {
+                        expect(urlParams[key]).toBe(value);
+                    });
+                    server.respond(requests);
+                };
+
+            beforeEach(function() {
+                collection = new PagingCollection([], {state: {pageSize: 10}});
+                collection.url = '/test';
+                server.isZeroIndexed = false;
+                server.count = 43;
             });
-            server.respond(requests);
-        };
-
-        beforeEach(function () {
-            collection = new PagingCollection([], { state: { pageSize: 10 } });
-            collection.url = '/test';
-            server.isZeroIndexed = false;
-            server.count = 43;
-        });
 
-        it('correctly merges state and queryParams in the extend statement', function () {
-            var MyPagingCollection, newCollection;
-            MyPagingCollection = PagingCollection.extend({
-                state: { pageSize: 25 },
-                queryParams: { pageSize: 'per_page' },
+            it('correctly merges state and queryParams in the extend statement', function() {
+                var MyPagingCollection, newCollection;
+                MyPagingCollection = PagingCollection.extend({
+                    state: {pageSize: 25},
+                    queryParams: {pageSize: 'per_page'}
+                });
+                newCollection = new MyPagingCollection([]);
+                expect(newCollection.state.pageSize).toBe(25);
+                expect(newCollection.state.firstPage).toBe(1);
+                expect(newCollection.queryParams.pageSize).toBe('per_page');
+                expect(newCollection.queryParams.currentPage).toBe('page');
             });
-            newCollection = new MyPagingCollection([]);
-            expect(newCollection.state.pageSize).toBe(25);
-            expect(newCollection.state.firstPage).toBe(1);
-            expect(newCollection.queryParams.pageSize).toBe('per_page');
-            expect(newCollection.queryParams.currentPage).toBe('page');
-        });
 
-        SpecHelpers.withData({
-            'correctly sets state when parse is set to true after instantiating': [null, null],
-            'correctly sets state when parse is set to true in set method': ['set', {
-                page: 3,
-                numPages: 5,
-                pageSize: 10,
-            }],
-            'correctly sets state when parse is set to true in reset method': ['reset', {
-                page: 3,
-                numPages: 3,
-                pageSize: 15,
-            }],
-        }, function (method, expectedState) {
-            var newCollection;
-            newCollection = new PagingCollection({
-                count: 43,
-                page: 2,
-                num_pages: 6,
-                page_size: 8,
-                results: [],
-            }, { parse: true });
-
-            expect(newCollection.getPageSize()).toBe(8);
-            expect(newCollection.getPageNumber()).toBe(2);
-            expect(newCollection.getTotalRecords()).toBe(43);
-            expect(newCollection.getTotalPages()).toBe(6);
-
-            if (method) {
-                newCollection[method]({
+            SpecHelpers.withData({
+                'correctly sets state when parse is set to true after instantiating': [null, null],
+                'correctly sets state when parse is set to true in set method': ['set', {
+                    page: 3,
+                    numPages: 5,
+                    pageSize: 10
+                }],
+                'correctly sets state when parse is set to true in reset method': ['reset', {
+                    page: 3,
+                    numPages: 3,
+                    pageSize: 15
+                }]
+            }, function(method, expectedState) {
+                var newCollection;
+                newCollection = new PagingCollection({
                     count: 43,
-                    page: expectedState.page,
-                    num_pages: expectedState.numPages,
-                    page_size: expectedState.pageSize,
-                    sort_order: -1,
-                    order_by: 'testcol',
-                    results: [],
-                }, { parse: true });
-
-                expect(newCollection.getPageSize()).toBe(expectedState.pageSize);
-                expect(newCollection.getPageNumber()).toBe(expectedState.page);
-                expect(newCollection.getTotalPages()).toBe(expectedState.numPages);
+                    page: 2,
+                    num_pages: 6,
+                    page_size: 8,
+                    results: []
+                }, {parse: true});
+
+                expect(newCollection.getPageSize()).toBe(8);
+                expect(newCollection.getPageNumber()).toBe(2);
                 expect(newCollection.getTotalRecords()).toBe(43);
-                expect(newCollection.state.sortKey).toBe('testcol');
-                expect(newCollection.state.order).toBe(-1);
-            }
-        });
+                expect(newCollection.getTotalPages()).toBe(6);
+
+                if (method) {
+                    newCollection[method]({
+                        count: 43,
+                        page: expectedState.page,
+                        num_pages: expectedState.numPages,
+                        page_size: expectedState.pageSize,
+                        sort_order: -1,
+                        order_by: 'testcol',
+                        results: []
+                    }, {parse: true});
+
+                    expect(newCollection.getPageSize()).toBe(expectedState.pageSize);
+                    expect(newCollection.getPageNumber()).toBe(expectedState.page);
+                    expect(newCollection.getTotalPages()).toBe(expectedState.numPages);
+                    expect(newCollection.getTotalRecords()).toBe(43);
+                    expect(newCollection.state.sortKey).toBe('testcol');
+                    expect(newCollection.state.order).toBe(-1);
+                }
+            });
 
-        it('can register sortable fields', function () {
-            collection.registerSortableField('test_field', 'Test Field');
-            expect('test_field' in collection.sortableFields).toBe(true);
-            expect(collection.sortableFields.test_field.displayName).toBe('Test Field');
-        });
+            it('can register sortable fields', function() {
+                collection.registerSortableField('test_field', 'Test Field');
+                expect('test_field' in collection.sortableFields).toBe(true);
+                expect(collection.sortableFields.test_field.displayName).toBe('Test Field');
+            });
 
-        it('can register filterable fields', function () {
-            collection.registerFilterableField('test_field', 'Test Field');
-            expect('test_field' in collection.filterableFields).toBe(true);
-            expect(collection.filterableFields.test_field.displayName).toBe('Test Field');
-        });
+            it('can register filterable fields', function() {
+                collection.registerFilterableField('test_field', 'Test Field');
+                expect('test_field' in collection.filterableFields).toBe(true);
+                expect(collection.filterableFields.test_field.displayName).toBe('Test Field');
+            });
 
-        it('can set the sort field', AjaxHelpers.withFakeRequests(function (requests) {
-            expect(collection.sortDisplayName()).toBe('');
-            collection.registerSortableField('test_field', 'Test Field');
-            collection.setSortField('test_field', false);
-            collection.refresh();
-            assertQueryParams(requests, { sort_order: 'asc' });
-            expect(collection.state.sortKey).toBe('test_field');
-            expect(collection.sortDisplayName()).toBe('Test Field');
-        }));
-
-        it('can tell the current sort direction', function () {
-            collection.setSortDirection(PagingCollection.SortDirection.ASCENDING);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
-            collection.setSortDirection(PagingCollection.SortDirection.DESCENDING);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
-        });
+            it('can set the sort field', AjaxHelpers.withFakeRequests(function(requests) {
+                expect(collection.sortDisplayName()).toBe('');
+                collection.registerSortableField('test_field', 'Test Field');
+                collection.setSortField('test_field', false);
+                collection.refresh();
+                assertQueryParams(requests, {sort_order: 'asc'});
+                expect(collection.state.sortKey).toBe('test_field');
+                expect(collection.sortDisplayName()).toBe('Test Field');
+            }));
+
+            it('can tell the current sort direction', function() {
+                collection.setSortDirection(PagingCollection.SortDirection.ASCENDING);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
+                collection.setSortDirection(PagingCollection.SortDirection.DESCENDING);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
+            });
 
-        it('can set a filter field', AjaxHelpers.withFakeRequests(function (requests) {
-            expect(collection.filterDisplayName('test_field')).toBe('');
-            collection.registerFilterableField('test_field', 'Test Field');
-            collection.setFilterField('test_field', 'test_value');
-            collection.refresh();
-            assertQueryParams(requests, { test_field: 'test_value' });
-            expect(collection.filterDisplayName('test_field')).toBe('Test Field');
-            expect(collection.getFilterFieldValue('test_field')).toBe('test_value');
-        }));
-
-        it('can set a filter field to an array', AjaxHelpers.withFakeRequests(function (requests) {
-            expect(collection.filterDisplayName('test_field')).toBe('');
-            collection.registerFilterableField('test_field', 'Test Field');
-            collection.setFilterField('test_field', ['a', 'b', 'c']);
-            collection.refresh();
-            assertQueryParams(requests, { test_field: 'a,b,c' });
-            expect(collection.filterDisplayName('test_field')).toBe('Test Field');
-            expect(collection.getFilterFieldValue('test_field')).toEqual(['a', 'b', 'c']);
-        }));
-
-        it('can set many filter fields', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.registerFilterableField('test_field_1', 'Test Field 1');
-            collection.registerFilterableField('test_field_2', 'Test Field 2');
-            collection.setFilterField('test_field_1', 'test_value_1');
-            collection.setFilterField('test_field_2', 'test_value_2');
-            collection.refresh();
-            assertQueryParams(requests, { test_field_1: 'test_value_1', test_field_2: 'test_value_2' });
-            expect(collection.filterDisplayName('test_field_1')).toBe('Test Field 1');
-            expect(collection.filterDisplayName('test_field_2')).toBe('Test Field 2');
-            expect(collection.filterableFields.test_field_1.value).toBe('test_value_1');
-            expect(collection.filterableFields.test_field_2.value).toBe('test_value_2');
-        }));
-
-        it('can unset a filter field', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.registerFilterableField('test_field', 'Test Field');
-            collection.setFilterField('test_field', 'test_value');
-            collection.refresh();
-            assertQueryParams(requests, { test_field: 'test_value' });
-            collection.unsetAllFilterFields();
-            collection.refresh();
-            expect('test_field' in getUrlParams(AjaxHelpers.currentRequest(requests))).not.toBe(true);
-        }));
-
-        it('can unset all filter fields', AjaxHelpers.withFakeRequests(function (requests) {
-            var currentRequest;
-            collection.registerFilterableField('test_field_1', 'Test Field 1');
-            collection.registerFilterableField('test_field_2', 'Test Field 2');
-            collection.setFilterField('test_field_1', 'test_value_1');
-            collection.setFilterField('test_field_2', 'test_value_2');
-            collection.refresh();
-            assertQueryParams(requests, { test_field_1: 'test_value_1', test_field_2: 'test_value_2' });
-            collection.unsetAllFilterFields();
-            collection.refresh();
-            currentRequest = AjaxHelpers.currentRequest(requests);
-            expect('test_field_1' in getUrlParams(currentRequest)).not.toBe(true);
-            expect('test_field_2' in getUrlParams(currentRequest)).not.toBe(true);
-        }));
-
-        it('can return the currently active filter fields', function () {
-            collection.registerFilterableField('test_field_1', 'Test Field 1');
-            collection.registerFilterableField('test_field_2', 'Test Field 2');
-            collection.registerFilterableField('test_field_3', 'Test Field 3');
-            collection.setFilterField('test_field_1', 'test_value_1');
-            collection.setFilterField('test_field_3', 'test_value_3');
-            collection.setSearchString('test string');
-            expect(collection.getActiveFilterFields())
-                .toEqual({ test_field_1: 'test_value_1', test_field_3: 'test_value_3' });
-        });
+            it('can set a filter field', AjaxHelpers.withFakeRequests(function(requests) {
+                expect(collection.filterDisplayName('test_field')).toBe('');
+                collection.registerFilterableField('test_field', 'Test Field');
+                collection.setFilterField('test_field', 'test_value');
+                collection.refresh();
+                assertQueryParams(requests, {test_field: 'test_value'});
+                expect(collection.filterDisplayName('test_field')).toBe('Test Field');
+                expect(collection.getFilterFieldValue('test_field')).toBe('test_value');
+            }));
+
+            it('can set a filter field to an array', AjaxHelpers.withFakeRequests(function(requests) {
+                expect(collection.filterDisplayName('test_field')).toBe('');
+                collection.registerFilterableField('test_field', 'Test Field');
+                collection.setFilterField('test_field', ['a', 'b', 'c']);
+                collection.refresh();
+                assertQueryParams(requests, {test_field: 'a,b,c'});
+                expect(collection.filterDisplayName('test_field')).toBe('Test Field');
+                expect(collection.getFilterFieldValue('test_field')).toEqual(['a', 'b', 'c']);
+            }));
+
+            it('can set many filter fields', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.registerFilterableField('test_field_1', 'Test Field 1');
+                collection.registerFilterableField('test_field_2', 'Test Field 2');
+                collection.setFilterField('test_field_1', 'test_value_1');
+                collection.setFilterField('test_field_2', 'test_value_2');
+                collection.refresh();
+                assertQueryParams(requests, {test_field_1: 'test_value_1', test_field_2: 'test_value_2'});
+                expect(collection.filterDisplayName('test_field_1')).toBe('Test Field 1');
+                expect(collection.filterDisplayName('test_field_2')).toBe('Test Field 2');
+                expect(collection.filterableFields.test_field_1.value).toBe('test_value_1');
+                expect(collection.filterableFields.test_field_2.value).toBe('test_value_2');
+            }));
+
+            it('can unset a filter field', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.registerFilterableField('test_field', 'Test Field');
+                collection.setFilterField('test_field', 'test_value');
+                collection.refresh();
+                assertQueryParams(requests, {test_field: 'test_value'});
+                collection.unsetAllFilterFields();
+                collection.refresh();
+                expect('test_field' in getUrlParams(AjaxHelpers.currentRequest(requests))).not.toBe(true);
+            }));
+
+            it('can unset all filter fields', AjaxHelpers.withFakeRequests(function(requests) {
+                var currentRequest;
+                collection.registerFilterableField('test_field_1', 'Test Field 1');
+                collection.registerFilterableField('test_field_2', 'Test Field 2');
+                collection.setFilterField('test_field_1', 'test_value_1');
+                collection.setFilterField('test_field_2', 'test_value_2');
+                collection.refresh();
+                assertQueryParams(requests, {test_field_1: 'test_value_1', test_field_2: 'test_value_2'});
+                collection.unsetAllFilterFields();
+                collection.refresh();
+                currentRequest = AjaxHelpers.currentRequest(requests);
+                expect('test_field_1' in getUrlParams(currentRequest)).not.toBe(true);
+                expect('test_field_2' in getUrlParams(currentRequest)).not.toBe(true);
+            }));
+
+            it('can return the currently active filter fields', function() {
+                collection.registerFilterableField('test_field_1', 'Test Field 1');
+                collection.registerFilterableField('test_field_2', 'Test Field 2');
+                collection.registerFilterableField('test_field_3', 'Test Field 3');
+                collection.setFilterField('test_field_1', 'test_value_1');
+                collection.setFilterField('test_field_3', 'test_value_3');
+                collection.setSearchString('test string');
+                expect(collection.getActiveFilterFields())
+                    .toEqual({test_field_1: 'test_value_1', test_field_3: 'test_value_3'});
+            });
 
-        it('can return the currently active filter fields', AjaxHelpers.withFakeRequests(function () {
-            var expectedRequestBody;
-            collection.registerFilterableField('test_field', 'Test Field');
-            collection.setFilterField('test_field', 'test value');
-            collection.setSearchString('test search');
-            expectedRequestBody = { test_field: 'test value' };
-            expectedRequestBody[PagingCollection.DefaultSearchKey] = 'test search';
-            expect(collection.getActiveFilterFields(true)).toEqual(expectedRequestBody);
-        }));
-
-        it('can tell if there is an active search', function () {
-            expect(collection.hasActiveSearch()).toBe(false);
-            collection.setSearchString('test search');
-            expect(collection.hasActiveSearch()).toBe(true);
-        });
+            it('can return the currently active filter fields', AjaxHelpers.withFakeRequests(function() {
+                var expectedRequestBody;
+                collection.registerFilterableField('test_field', 'Test Field');
+                collection.setFilterField('test_field', 'test value');
+                collection.setSearchString('test search');
+                expectedRequestBody = {test_field: 'test value'};
+                expectedRequestBody[PagingCollection.DefaultSearchKey] = 'test search';
+                expect(collection.getActiveFilterFields(true)).toEqual(expectedRequestBody);
+            }));
+
+            it('can tell if there is an active search', function() {
+                expect(collection.hasActiveSearch()).toBe(false);
+                collection.setSearchString('test search');
+                expect(collection.hasActiveSearch()).toBe(true);
+            });
 
-        it('can get the value of a particular filter field', function () {
-            collection.registerFilterableField('test_field_1', 'Test Field 1');
-            collection.registerFilterableField('test_field_2', 'Test Field 2');
-            collection.setFilterField('test_field_1', 'test_value_1');
-            expect(collection.getFilterFieldValue('test_field_1')).toEqual('test_value_1');
-            collection.unsetFilterField('test_field_1');
-            expect(collection.getFilterFieldValue('test_field_1')).toBe(null);
-            expect(collection.getFilterFieldValue('test_field_2')).toBe(null);
-            expect(collection.getFilterFieldValue('no_such_field')).toBe(null);
-        });
+            it('can get the value of a particular filter field', function() {
+                collection.registerFilterableField('test_field_1', 'Test Field 1');
+                collection.registerFilterableField('test_field_2', 'Test Field 2');
+                collection.setFilterField('test_field_1', 'test_value_1');
+                expect(collection.getFilterFieldValue('test_field_1')).toEqual('test_value_1');
+                collection.unsetFilterField('test_field_1');
+                expect(collection.getFilterFieldValue('test_field_1')).toBe(null);
+                expect(collection.getFilterFieldValue('test_field_2')).toBe(null);
+                expect(collection.getFilterFieldValue('no_such_field')).toBe(null);
+            });
 
-        it('can set the sort direction', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.setSortField('test_field');
-            collection.setSortDirection(PagingCollection.SortDirection.DESCENDING);
-            collection.refresh();
-            assertQueryParams(requests, { sort_order: PagingCollection.SortDirection.DESCENDING });
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
-            collection.setSortDirection(PagingCollection.SortDirection.ASCENDING);
-            collection.refresh();
-            assertQueryParams(requests, { sort_order: PagingCollection.SortDirection.ASCENDING });
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
-        }));
-
-        it('can flip the sort direction', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.setSortField('test_field');
-            collection.refresh();
-            assertQueryParams(requests, { sort_order: PagingCollection.SortDirection.ASCENDING });
-            collection.flipSortDirection();
-            collection.refresh();
-            assertQueryParams(requests, { sort_order: PagingCollection.SortDirection.DESCENDING });
-        }));
-
-        it('can toggle the sort direction when setting the sort field', function () {
-            collection.registerSortableField('test_field', 'Test Field');
-            collection.registerSortableField('test_field_2', 'Test Field 2');
-            collection.setSortField('test_field', true);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
-            collection.setSortField('test_field', true);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
-            collection.setSortField('test_field', true);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
-            collection.setSortField('test_field_2');
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
-            collection.setSortField('test_field_2', true);
-            expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
-        });
+            it('can set the sort direction', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.setSortField('test_field');
+                collection.setSortDirection(PagingCollection.SortDirection.DESCENDING);
+                collection.refresh();
+                assertQueryParams(requests, {sort_order: PagingCollection.SortDirection.DESCENDING});
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
+                collection.setSortDirection(PagingCollection.SortDirection.ASCENDING);
+                collection.refresh();
+                assertQueryParams(requests, {sort_order: PagingCollection.SortDirection.ASCENDING});
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
+            }));
 
-        it('can set and unset the search string', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.setSearchString('testString');
-            collection.refresh();
-            assertQueryParams(requests, { text_search: 'testString' });
-            collection.unsetSearchString();
-            collection.refresh();
-            expect('text_search' in getUrlParams(AjaxHelpers.currentRequest(requests))).not.toBe(true);
-        }));
-
-        it('can get the current search string', AjaxHelpers.withFakeRequests(function (requests) {
-            collection.setSearchString('test string');
-            collection.refresh();
-            server.respond(requests);
-            expect(collection.getSearchString()).toBe('test string');
-        }));
-
-        it('does not refresh if search string is unchanged',
-            AjaxHelpers.withFakeRequests(function (requests) {
-                var testString = 'testString';
-                collection.setSearchString(testString);
+            it('can flip the sort direction', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.setSortField('test_field');
                 collection.refresh();
-                server.respond(requests);
-                collection.setSearchString(testString);
+                assertQueryParams(requests, {sort_order: PagingCollection.SortDirection.ASCENDING});
+                collection.flipSortDirection();
                 collection.refresh();
-                expect(requests.length).toEqual(1);
-            }),
-        );
-
-        SpecHelpers.withData({
-            'queries with page, page_size, and sort_order parameters when zero indexed': [true, 2],
-            'queries with page, page_size, and sort_order parameters when one indexed': [false, 3],
-        }, AjaxHelpers.withFakeRequests(function (isZeroIndexed, page, requests) {
-            collection = new PagingCollection([], { state: { firstPage: isZeroIndexed ? 0 : 1, pageSize: 5 } });
-            collection.url = '/test';
-            collection.setSortField('test_field');
-            collection.setPage(3);
-            assertQueryParams(requests, {
-                page: page.toString(),
-                page_size: '5',
-                order_by: 'test_field',
-                sort_order: 'asc',
+                assertQueryParams(requests, {sort_order: PagingCollection.SortDirection.DESCENDING});
+            }));
+
+            it('can toggle the sort direction when setting the sort field', function() {
+                collection.registerSortableField('test_field', 'Test Field');
+                collection.registerSortableField('test_field_2', 'Test Field 2');
+                collection.setSortField('test_field', true);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
+                collection.setSortField('test_field', true);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
+                collection.setSortField('test_field', true);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
+                collection.setSortField('test_field_2');
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.DESCENDING);
+                collection.setSortField('test_field_2', true);
+                expect(collection.sortDirection()).toBe(PagingCollection.SortDirection.ASCENDING);
             });
-        }));
-
-        it('has instance-unique filterableFields and sortablefields', function () {
-            var otherCollection = new PagingCollection([], { state: { pageSize: 10 } });
-            collection.registerFilterableField('foo', 'foo');
-            collection.setFilterField('foo', 'bar');
-            collection.registerSortableField('quux', 'quux');
-            expect(collection.filterableFields).not.toBe(otherCollection.filterableFields);
-            expect(collection.sortableFields).not.toBe(otherCollection.sortableFields);
-        });
 
-        SpecHelpers.withConfiguration({
-            'using a zero indexed collection': [true],
-            'using a one indexed collection': [false],
-        }, function (isZeroIndexed) {
-            collection.state.firstPage = isZeroIndexed ? 0 : 1;
-            server.isZeroIndexed = isZeroIndexed;
-        }, function () {
-            describe('setPage', function () {
-                it('triggers a reset event when the page changes successfully',
-                    AjaxHelpers.withFakeRequests(function (requests) {
-                        var resetTriggered = false;
-                        collection.on('reset', function () { resetTriggered = true; });
-                        collection.setPage(3);
-                        server.respond(requests);
-                        expect(resetTriggered).toBe(true);
-                    }),
-                );
-
-                it('triggers an error event when the requested page is out of range',
-                    AjaxHelpers.withFakeRequests(function (requests) {
-                        var errorTriggered = false;
-                        collection.on('error', function () { errorTriggered = true; });
-                        collection.setPage(17);
-                        server.respond(requests);
-                        expect(errorTriggered).toBe(true);
-                    }),
-                );
-
-                it('triggers an error event if the server responds with a 500',
-                    AjaxHelpers.withFakeRequests(function (requests) {
-                        var errorTriggered = false;
-                        collection.on('error', function () { errorTriggered = true; });
-                        collection.setPage(2);
-                        expect(collection.getPageNumber()).toBe(2);
-                        server.respond(requests);
-                        collection.setPage(3);
-                        AjaxHelpers.respondWithError(requests);
-                        expect(errorTriggered).toBe(true);
-                        expect(collection.getPageNumber()).toBe(2);
-                    }),
-                );
-            });
+            it('can set and unset the search string', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.setSearchString('testString');
+                collection.refresh();
+                assertQueryParams(requests, {text_search: 'testString'});
+                collection.unsetSearchString();
+                collection.refresh();
+                expect('text_search' in getUrlParams(AjaxHelpers.currentRequest(requests))).not.toBe(true);
+            }));
 
-            describe('getPageNumber', function () {
-                it('returns the correct page', AjaxHelpers.withFakeRequests(function (requests) {
-                    collection.setPage(1);
-                    server.respond(requests);
-                    expect(collection.getPageNumber()).toBe(1);
-                    collection.setPage(3);
+            it('can get the current search string', AjaxHelpers.withFakeRequests(function(requests) {
+                collection.setSearchString('test string');
+                collection.refresh();
+                server.respond(requests);
+                expect(collection.getSearchString()).toBe('test string');
+            }));
+
+            it('does not refresh if search string is unchanged',
+                AjaxHelpers.withFakeRequests(function(requests) {
+                    var testString = 'testString';
+                    collection.setSearchString(testString);
+                    collection.refresh();
                     server.respond(requests);
-                    expect(collection.getPageNumber()).toBe(3);
-                }));
+                    collection.setSearchString(testString);
+                    collection.refresh();
+                    expect(requests.length).toEqual(1);
+                })
+            );
+
+            SpecHelpers.withData({
+                'queries with page, page_size, and sort_order parameters when zero indexed': [true, 2],
+                'queries with page, page_size, and sort_order parameters when one indexed': [false, 3]
+            }, AjaxHelpers.withFakeRequests(function(isZeroIndexed, page, requests) {
+                collection = new PagingCollection([], {state: {firstPage: isZeroIndexed ? 0 : 1, pageSize: 5}});
+                collection.url = '/test';
+                collection.setSortField('test_field');
+                collection.setPage(3);
+                assertQueryParams(requests, {
+                    page: page.toString(),
+                    page_size: '5',
+                    order_by: 'test_field',
+                    sort_order: 'asc'
+                });
+            }));
+
+            it('has instance-unique filterableFields and sortablefields', function() {
+                var otherCollection = new PagingCollection([], {state: {pageSize: 10}});
+                collection.registerFilterableField('foo', 'foo');
+                collection.setFilterField('foo', 'bar');
+                collection.registerSortableField('quux', 'quux');
+                expect(collection.filterableFields).not.toBe(otherCollection.filterableFields);
+                expect(collection.sortableFields).not.toBe(otherCollection.sortableFields);
             });
 
-            describe('hasNextPage', function () {
-                SpecHelpers.withData(
-                    {
-                        'returns false for a single page': [1, 3, false],
-                        'returns true on the first page': [1, 43, true],
-                        'returns true on the penultimate page': [4, 43, true],
-                        'returns false on the last page': [5, 43, false],
-                    },
-                    AjaxHelpers.withFakeRequests(function (page, count, result, requests) {
-                        server.count = count;
-                        collection.setPage(page);
-                        server.respond(requests);
-                        expect(collection.hasNextPage()).toBe(result);
-                    }),
-                );
-            });
-
-            describe('hasPreviousPage', function () {
-                SpecHelpers.withData(
-                    {
-                        'returns false for a single page': [1, 3, false],
-                        'returns true on the last page': [5, 43, true],
-                        'returns true on the second page': [2, 43, true],
-                        'returns false on the first page': [1, 43, false],
-                    },
-                    AjaxHelpers.withFakeRequests(function (page, count, result, requests) {
-                        server.count = count;
-                        collection.setPage(page);
+            SpecHelpers.withConfiguration({
+                'using a zero indexed collection': [true],
+                'using a one indexed collection': [false]
+            }, function(isZeroIndexed) {
+                collection.state.firstPage = isZeroIndexed ? 0 : 1;
+                server.isZeroIndexed = isZeroIndexed;
+            }, function() {
+                describe('setPage', function() {
+                    it('triggers a reset event when the page changes successfully',
+                        AjaxHelpers.withFakeRequests(function(requests) {
+                            var resetTriggered = false;
+                            collection.on('reset', function() { resetTriggered = true; });
+                            collection.setPage(3);
+                            server.respond(requests);
+                            expect(resetTriggered).toBe(true);
+                        })
+                    );
+
+                    it('triggers an error event when the requested page is out of range',
+                        AjaxHelpers.withFakeRequests(function(requests) {
+                            var errorTriggered = false;
+                            collection.on('error', function() { errorTriggered = true; });
+                            collection.setPage(17);
+                            server.respond(requests);
+                            expect(errorTriggered).toBe(true);
+                        })
+                    );
+
+                    it('triggers an error event if the server responds with a 500',
+                        AjaxHelpers.withFakeRequests(function(requests) {
+                            var errorTriggered = false;
+                            collection.on('error', function() { errorTriggered = true; });
+                            collection.setPage(2);
+                            expect(collection.getPageNumber()).toBe(2);
+                            server.respond(requests);
+                            collection.setPage(3);
+                            AjaxHelpers.respondWithError(requests);
+                            expect(errorTriggered).toBe(true);
+                            expect(collection.getPageNumber()).toBe(2);
+                        })
+                    );
+                });
+
+                describe('getPageNumber', function() {
+                    it('returns the correct page', AjaxHelpers.withFakeRequests(function(requests) {
+                        collection.setPage(1);
                         server.respond(requests);
-                        expect(collection.hasPreviousPage()).toBe(result);
-                    }),
-                );
-            });
-
-            describe('nextPage', function () {
-                SpecHelpers.withData(
-                    {
-                        'advances to the next page': [2, 43, 3],
-                        'silently fails on the last page': [5, 43, 5],
-                    },
-                    AjaxHelpers.withFakeRequests(function (page, count, newPage, requests) {
-                        server.count = count;
-                        collection.setPage(page);
+                        expect(collection.getPageNumber()).toBe(1);
+                        collection.setPage(3);
                         server.respond(requests);
-                        expect(collection.getPageNumber()).toBe(page);
-                        collection.nextPage();
-                        if (requests.length > 1) {
+                        expect(collection.getPageNumber()).toBe(3);
+                    }));
+                });
+
+                describe('hasNextPage', function() {
+                    SpecHelpers.withData(
+                        {
+                            'returns false for a single page': [1, 3, false],
+                            'returns true on the first page': [1, 43, true],
+                            'returns true on the penultimate page': [4, 43, true],
+                            'returns false on the last page': [5, 43, false]
+                        },
+                        AjaxHelpers.withFakeRequests(function(page, count, result, requests) {
+                            server.count = count;
+                            collection.setPage(page);
                             server.respond(requests);
-                        }
-                        expect(collection.getPageNumber()).toBe(newPage);
-                    }),
-                );
-            });
-
-            describe('previousPage', function () {
-                SpecHelpers.withData(
-                    {
-                        'moves to the previous page': [2, 43, 1],
-                        'silently fails on the first page': [1, 43, 1],
-                    },
-                    AjaxHelpers.withFakeRequests(function (page, count, newPage, requests) {
-                        server.count = count;
-                        collection.setPage(page);
-                        server.respond(requests);
-                        expect(collection.getPageNumber()).toBe(page);
-                        collection.previousPage();
-                        if (requests.length > 1) {
+                            expect(collection.hasNextPage()).toBe(result);
+                        })
+                    );
+                });
+
+                describe('hasPreviousPage', function() {
+                    SpecHelpers.withData(
+                        {
+                            'returns false for a single page': [1, 3, false],
+                            'returns true on the last page': [5, 43, true],
+                            'returns true on the second page': [2, 43, true],
+                            'returns false on the first page': [1, 43, false]
+                        },
+                        AjaxHelpers.withFakeRequests(function(page, count, result, requests) {
+                            server.count = count;
+                            collection.setPage(page);
                             server.respond(requests);
-                        }
-                        expect(collection.getPageNumber()).toBe(newPage);
-                    }),
-                );
+                            expect(collection.hasPreviousPage()).toBe(result);
+                        })
+                    );
+                });
+
+                describe('nextPage', function() {
+                    SpecHelpers.withData(
+                        {
+                            'advances to the next page': [2, 43, 3],
+                            'silently fails on the last page': [5, 43, 5]
+                        },
+                        AjaxHelpers.withFakeRequests(function(page, count, newPage, requests) {
+                            server.count = count;
+                            collection.setPage(page);
+                            server.respond(requests);
+                            expect(collection.getPageNumber()).toBe(page);
+                            collection.nextPage();
+                            if (requests.length > 1) {
+                                server.respond(requests);
+                            }
+                            expect(collection.getPageNumber()).toBe(newPage);
+                        })
+                    );
+                });
+
+                describe('previousPage', function() {
+                    SpecHelpers.withData(
+                        {
+                            'moves to the previous page': [2, 43, 1],
+                            'silently fails on the first page': [1, 43, 1]
+                        },
+                        AjaxHelpers.withFakeRequests(function(page, count, newPage, requests) {
+                            server.count = count;
+                            collection.setPage(page);
+                            server.respond(requests);
+                            expect(collection.getPageNumber()).toBe(page);
+                            collection.previousPage();
+                            if (requests.length > 1) {
+                                server.respond(requests);
+                            }
+                            expect(collection.getPageNumber()).toBe(newPage);
+                        })
+                    );
+                });
             });
         });
-    });
-},
+    }
 );
diff --git a/src/js/utils/constants.js b/src/js/utils/constants.js
index eb0db12c..d9928f76 100644
--- a/src/js/utils/constants.js
+++ b/src/js/utils/constants.js
@@ -1,10 +1,10 @@
 /**
  * Reusable constants.
  */
-(function (define) {
+(function(define) {
     'use strict';
 
-    define([], function () {
+    define([], function() {
         /**
          * Reusable constants.
          *
@@ -31,7 +31,7 @@
                 left: 'ArrowLeft',
                 up: 'ArrowUp',
                 right: 'ArrowRight',
-                down: 'ArrowDown',
+                down: 'ArrowDown'
             },
             // NOTE: keyCode is deprecated. Use the `key` or `code` event property if possible.
             // See: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode
@@ -43,8 +43,8 @@
                 left: 37,
                 up: 38,
                 right: 39,
-                down: 40,
-            },
+                down: 40
+            }
         };
     });
 }).call(
@@ -54,7 +54,7 @@
     // 2. If not, use 'RequireJS.define' if that is available
     // 3. else use the GlobalLoader to install the class into the edx namespace
     // eslint-disable-next-line no-nested-ternary
-    typeof define === 'function' && define.amd ? define
-        : (typeof RequireJS !== 'undefined' ? RequireJS.define
-            : edx.GlobalLoader.defineAs('constants', 'edx-ui-toolkit/js/utils/constants')),
+    typeof define === 'function' && define.amd ? define :
+        (typeof RequireJS !== 'undefined' ? RequireJS.define :
+            edx.GlobalLoader.defineAs('constants', 'edx-ui-toolkit/js/utils/constants'))
 );
diff --git a/src/js/utils/date-utils.js b/src/js/utils/date-utils.js
index b1cbbfe2..18300fb2 100644
--- a/src/js/utils/date-utils.js
+++ b/src/js/utils/date-utils.js
@@ -24,18 +24,19 @@
  * @module DateUtils
  */
 
-(function (define) {
+
+(function(define) {
     'use strict';
 
     define([
         'jquery',
         'moment',
-        'moment-timezone',
-    ], function (
+        'moment-timezone'
+    ], function(
         $,
         moment,
-        momentTZ,
-    ) {
+        momentTZ
+        ) {
         var DateUtils,
             localize,
             stringToMoment,
@@ -52,7 +53,7 @@
             time: 'LTS z', // example: 15:30:32 UTC
             defaultFormat: 'll HH[:]mm z', // example: Jan 01, 2016 15:30 UTC
             defaultWithParen: 'll HH[:]mm (z)', // example: Jan 01, 2016 15:30 (UTC)
-            longDateTime: 'dddd, ll HH[:]mm z', // example: Friday, Jan 01, 2016 15:30 UTC
+            longDateTime: 'dddd, ll HH[:]mm z' // example: Friday, Jan 01, 2016 15:30 UTC
         });
 
         var DEFAULT_LANG = 'en';
@@ -74,14 +75,14 @@
          * @returns {string} A formatted, timezone-offset, internationalized date and time.
          *
          */
-        localize = function (context) {
+        localize = function(context) {
             var localTime;
             var displayTime = '';
 
             if (isValid(context.datetime)) {
                 localTime = localizeTime(
                     DateUtils.stringToMoment(context.datetime),
-                    context.timezone,
+                    context.timezone
                 );
                 displayTime = getDisplayTime(localTime, context.language, context.format);
             }
@@ -103,7 +104,7 @@
          * @returns {object} A moment.js UTC datetime object.
          *
         */
-        stringToMoment = function (datetimeString) {
+        stringToMoment = function(datetimeString) {
             var utcDateObject;
             if (isValid(datetimeString)) {
                 utcDateObject = moment(datetimeString).utc();
@@ -121,7 +122,7 @@
          * @param {string} timezone A timezone representation, e.g. 'America/New_York'.
          * @return {object} A moment.js datetime object in a determined timezone.
          */
-        localizeTime = function (dateTimeObject, timezone) {
+        localizeTime = function(dateTimeObject, timezone) {
             var localTime;
             if (isValid(dateTimeObject) && isValid(timezone)) {
                 localTime = dateTimeObject.tz(timezone);
@@ -141,7 +142,7 @@
          * @return {string} Will attempt to return a determined timezone string, with a fallback to UTC.
          *
          */
-        getSysTimezone = function () {
+        getSysTimezone = function() {
             var timezone = momentTZ.tz.guess();
             if (!isValid(timezone)) {
                 timezone = DEFAULT_TIMEZONE;
@@ -171,7 +172,7 @@
          * @param {object} format (optional) A desired date format, via the dateFormatEnum.
          * @return {string} A language/timezone aware localized string
         */
-        getDisplayTime = function (localTime, language, format) {
+        getDisplayTime = function(localTime, language, format) {
             var displayTime = '';
             var displayLang = getDisplayLang(language);
             var displayFormat = getDisplayFormat(format);
@@ -190,7 +191,7 @@
          * @param {string} language (optional) an ISO 639-1 language code (e.g. 'en-US', 'fr')
          * @returns {string} an ISO 639-1 language code (e.g. 'en-US', 'fr')
          */
-        getDisplayLang = function (language) {
+        getDisplayLang = function(language) {
             var displayLang;
             if (isValid(language)) {
                 displayLang = language;
@@ -200,8 +201,9 @@
             // default
             if (isValid(language)) {
                 return displayLang;
+            } else {
+                return DEFAULT_LANG;
             }
-            return DEFAULT_LANG;
         };
 
         /**
@@ -212,7 +214,7 @@
          * @param {object} format (optional) A format constant.
          * @returns {string} A format constant.
          */
-        getDisplayFormat = function (format) {
+        getDisplayFormat = function(format) {
             var displayFormat = DEFAULT_FORMAT;
             if (isValid(format)) {
                 displayFormat = format;
@@ -226,7 +228,7 @@
          * @param {string} candidateVariable to test
          * @returns {boolean}
          */
-        isValid = function (candidateVariable) {
+        isValid = function(candidateVariable) {
             return candidateVariable !== undefined
                 && candidateVariable !== ''
                 && candidateVariable !== 'Invalid date'
@@ -238,7 +240,7 @@
             localize: localize,
             stringToMoment: stringToMoment,
             getSysTimezone: getSysTimezone,
-            localizeTime: localizeTime,
+            localizeTime: localizeTime
         };
         return DateUtils;
     });
@@ -249,7 +251,8 @@
     // 2. If not, use 'RequireJS.define' if that is available
     // 3. else use the GlobalLoader to install the class into the edx namespace
     // eslint-disable-next-line no-nested-ternary
-    typeof define === 'function' && define.amd ? define
-        : (typeof RequireJS !== 'undefined' ? RequireJS.define
-            : edx.GlobalLoader.defineAs('DateUtils', 'edx-ui-toolkit/js/utils/date-utils')),
+    typeof define === 'function' && define.amd ? define :
+        (typeof RequireJS !== 'undefined' ? RequireJS.define :
+            edx.GlobalLoader.defineAs('DateUtils', 'edx-ui-toolkit/js/utils/date-utils'))
 );
+
diff --git a/src/js/utils/global-loader.js b/src/js/utils/global-loader.js
index 116b243e..8a819b38 100644
--- a/src/js/utils/global-loader.js
+++ b/src/js/utils/global-loader.js
@@ -4,12 +4,12 @@
  * @module GlobalLoader
  */
 /* global $ */
-(function () {
+(function() {
     'use strict';
 
     window.edx = window.edx || {};
 
-    window.edx.GlobalLoader = (function () {
+    window.edx.GlobalLoader = (function() {
         var registeredModules = {},
             GlobalLoader;
 
@@ -46,8 +46,8 @@
              * @param {string} path The module's path.
              * @returns {Function} A function that will create the module.
              */
-            defineAs: function (name, path) {
-                return function (requiredPaths, moduleFunction) {
+            defineAs: function(name, path) {
+                return function(requiredPaths, moduleFunction) {
                     var requiredModules = [],
                         pathCount = requiredPaths.length,
                         requiredModule,
@@ -68,9 +68,9 @@
              *
              * Note: this function is only provided for unit testing.
              */
-            clear: function () {
+            clear: function() {
                 registeredModules = {};
-            },
+            }
         };
 
         return GlobalLoader;
diff --git a/src/js/utils/html-utils.js b/src/js/utils/html-utils.js
index 6d971e02..1217c237 100644
--- a/src/js/utils/html-utils.js
+++ b/src/js/utils/html-utils.js
@@ -10,10 +10,10 @@
  *
  * @module HtmlUtils
  */
-(function (define) {
+(function(define) {
     'use strict';
 
-    define(['underscore', 'jquery', 'edx-ui-toolkit/js/utils/string-utils'], function (_, $, StringUtils) {
+    define(['underscore', 'jquery', 'edx-ui-toolkit/js/utils/string-utils'], function(_, $, StringUtils) {
         var HtmlUtils, ensureHtml, interpolateHtml, joinHtml, HTML, template, setHtml, append, prepend;
 
         /**
@@ -29,10 +29,10 @@
         function HtmlSnippet(htmlString) {
             this.text = htmlString;
         }
-        HtmlSnippet.prototype.valueOf = function () {
+        HtmlSnippet.prototype.valueOf = function() {
             return this.text;
         };
-        HtmlSnippet.prototype.toString = function () {
+        HtmlSnippet.prototype.toString = function() {
             return this.text;
         };
 
@@ -45,7 +45,7 @@
          * @param {string} htmlString The string of HTML.
          * @returns {HtmlSnippet} An HTML snippet that can be safely rendered.
          */
-        HTML = function (htmlString) {
+        HTML = function(htmlString) {
             return new HtmlSnippet(htmlString);
         };
 
@@ -60,11 +60,12 @@
          * or an HTML snippet.
          * @returns {HtmlSnippet} A safely escaped HTML snippet.
          */
-        ensureHtml = function (html) {
+        ensureHtml = function(html) {
             if (html instanceof HtmlSnippet) {
                 return html;
+            } else {
+                return HTML(_.escape(html));
             }
-            return HTML(_.escape(html));
         };
 
         /**
@@ -133,10 +134,10 @@
          * @param {Object} parameters An optional set of parameters for interpolation.
          * @returns {HtmlSnippet} The resulting safely escaped HTML snippet.
          */
-        interpolateHtml = function (formatString, parameters) {
+        interpolateHtml = function(formatString, parameters) {
             var result = StringUtils.interpolate(
                 ensureHtml(formatString).toString(),
-                _.mapObject(parameters, ensureHtml),
+                _.mapObject(parameters, ensureHtml)
             );
             return HTML(result);
         };
@@ -153,12 +154,11 @@
          * to be joined together.
          * @returns {HtmlSnippet} The resulting safely escaped HTML snippet.
          */
-        joinHtml = function () {
+        joinHtml = function() {
             var html = '',
                 argumentCount = arguments.length,
                 i;
             for (i = 0; i < argumentCount; i += 1) {
-                // eslint-disable-next-line prefer-rest-params
                 html += ensureHtml(arguments[i]);
             }
             return HTML(html);
@@ -177,14 +177,14 @@
          * @param {object} settings
          * @returns {function} A function that returns a rendered HTML snippet.
          */
-        template = function (text, settings) {
-            return function (data) {
+        template = function(text, settings) {
+            return function(data) {
                 var augmentedData = _.extend(
                     {
                         HtmlUtils: HtmlUtils,
-                        StringUtils: StringUtils,
+                        StringUtils: StringUtils
                     },
-                    data || {},
+                    data || {}
                 );
                 return HTML(_.template(text, settings)(augmentedData));
             };
@@ -202,7 +202,7 @@
          * plain string or as an HTML snippet.
          * @returns {JQuery} The JQuery object representing the element or elements.
          */
-        setHtml = function (element, html) {
+        setHtml = function(element, html) {
             return $(element).html(ensureHtml(html).toString());
         };
 
@@ -218,7 +218,7 @@
          * plain string or as an HTML snippet.
          * @returns {JQuery} The JQuery object representing the element or elements.
          */
-        append = function (element, html) {
+        append = function(element, html) {
             return $(element).append(ensureHtml(html).toString());
         };
 
@@ -234,7 +234,7 @@
          * plain string or as an HTML snippet.
          * @returns {JQuery} The JQuery object representing the element or elements.
          */
-        prepend = function (element, html) {
+        prepend = function(element, html) {
             return $(element).prepend(ensureHtml(html).toString());
         };
 
@@ -247,7 +247,7 @@
             joinHtml: joinHtml,
             prepend: prepend,
             setHtml: setHtml,
-            template: template,
+            template: template
         };
 
         return HtmlUtils;
@@ -259,7 +259,7 @@
     // 2. If not, use 'RequireJS.define' if that is available
     // 3. else use the GlobalLoader to install the class into the edx namespace
     // eslint-disable-next-line no-nested-ternary
-    typeof define === 'function' && define.amd ? define
-        : (typeof RequireJS !== 'undefined' ? RequireJS.define
-            : edx.GlobalLoader.defineAs('HtmlUtils', 'edx-ui-toolkit/js/utils/html-utils')),
+    typeof define === 'function' && define.amd ? define :
+        (typeof RequireJS !== 'undefined' ? RequireJS.define :
+            edx.GlobalLoader.defineAs('HtmlUtils', 'edx-ui-toolkit/js/utils/html-utils'))
 );
diff --git a/src/js/utils/spec-helpers/ajax-helpers.js b/src/js/utils/spec-helpers/ajax-helpers.js
index 3c959912..fab4d543 100644
--- a/src/js/utils/spec-helpers/ajax-helpers.js
+++ b/src/js/utils/spec-helpers/ajax-helpers.js
@@ -12,7 +12,7 @@
  *
  * @module AjaxHelpers
  */
-define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
+define(['sinon', 'underscore', 'URI'], function(sinon, _, URI) {
     'use strict';
 
     var XHR_READY_STATES, fakeServer, createFakeRequests, withFakeRequests, fakeRequests, currentRequest,
@@ -26,7 +26,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
         UNSENT: 0,
         OPENED: 1,
         LOADING: 3,
-        DONE: 4,
+        DONE: 4
     };
 
     /* These utility methods are used by Jasmine tests to create a mock server or
@@ -48,9 +48,9 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {string} response the fake response.
      * @returns {*} The current request.
      */
-    fakeServer = function (response) {
+    fakeServer = function(response) {
         var server = sinon.fakeServer.create();
-        afterEach(function () {
+        afterEach(function() {
             if (server) {
                 server.restore();
             }
@@ -59,17 +59,17 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
         return server;
     };
 
-    createFakeRequests = function () {
+    createFakeRequests = function() {
         var requests = [],
             xhr = sinon.useFakeXMLHttpRequest();
 
         requests.currentIndex = 0;
-        requests.restore = function () {
+        requests.restore = function() {
             if (xhr && 'restore' in xhr) {
                 xhr.restore();
             }
         };
-        xhr.onCreate = function (request) {
+        xhr.onCreate = function(request) {
             requests.push(request);
         };
 
@@ -82,9 +82,9 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      *
      * @returns {Array} An array tracking the fake requests.
      */
-    fakeRequests = function () {
+    fakeRequests = function() {
         var requests = createFakeRequests();
-        afterEach(function () {
+        afterEach(function() {
             requests.restore();
         });
         return requests;
@@ -97,12 +97,10 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {function} test A function to be invoked with the fake requests.
      * @returns {function} A wrapped version of the input function.
      */
-    withFakeRequests = function (test) {
-        return function () {
-            var requests = createFakeRequests();
-            // eslint-disable-next-line prefer-rest-params
-            var args = Array.prototype.slice.call(arguments);
-            // eslint-disable-next-line prefer-spread
+    withFakeRequests = function(test) {
+        return function() {
+            var requests = createFakeRequests(),
+                args = Array.prototype.slice.call(arguments);
             test.apply(null, args.concat([requests]));
             requests.restore();
         };
@@ -115,7 +113,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {object} requests an array of fired sinon requests
      * @returns {*} The current request.
      */
-    currentRequest = function (requests) {
+    currentRequest = function(requests) {
         expect(requests.length).toBeGreaterThan(requests.currentIndex);
         return requests[requests.currentIndex];
     };
@@ -128,7 +126,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {string} url the expected url of the request
      * @param {string} body the expected request body
      */
-    expectRequest = function (requests, method, url, body) {
+    expectRequest = function(requests, method, url, body) {
         var request = currentRequest(requests);
         expect(request.readyState).toEqual(XHR_READY_STATES.OPENED);
         expect(request.url).toEqual(url);
@@ -146,7 +144,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      *
      * @param {object} requests an array of fired sinon requests
      */
-    expectNoRequests = function (requests) {
+    expectNoRequests = function(requests) {
         expect(requests.length).toEqual(requests.currentIndex);
     };
 
@@ -158,7 +156,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {string} url the expected url of the request
      * @param {object} jsonRequest the expected request body as an object
      */
-    expectJsonRequest = function (requests, method, url, jsonRequest) {
+    expectJsonRequest = function(requests, method, url, jsonRequest) {
         var request = currentRequest(requests);
         expect(request.readyState).toEqual(XHR_READY_STATES.OPENED);
         expect(request.url).toEqual(url);
@@ -173,12 +171,12 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {string} expectedUrl The expected URL excluding the parameters
      * @param {object} expectedParameters An object representing the URL parameters
      */
-    expectRequestURL = function (requests, expectedUrl, expectedParameters) {
+    expectRequestURL = function(requests, expectedUrl, expectedParameters) {
         var request = currentRequest(requests),
             parameters;
         expect(new URI(request.url).path()).toEqual(expectedUrl);
         parameters = new URI(request.url).query(true);
-        delete parameters._; // Ignore the cache-busting argument
+        delete parameters._;  // Ignore the cache-busting argument
         expect(parameters).toEqual(expectedParameters);
     };
 
@@ -189,7 +187,7 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {string} url the expected url of the request
      * @param {string} body the expected body of the request
      */
-    expectPostRequest = function (requests, url, body) {
+    expectPostRequest = function(requests, url, body) {
         var request = currentRequest(requests);
         expect(request.readyState).toEqual(XHR_READY_STATES.OPENED);
         expect(request.url).toEqual(url);
@@ -206,11 +204,11 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
 
      * @param {object} requests an array of fired sinon requests
      */
-    skipResetRequest = function (requests) {
+    skipResetRequest = function(requests) {
         var request = currentRequest(requests);
         expect(request.readyState).toEqual(XHR_READY_STATES.UNSENT);
         // Our ESLint config bans mutating params, but fixing this would require breaking AjaxHelpers API
-        requests.currentIndex += 1;
+        requests.currentIndex += 1;  // eslint-disable-line no-param-reassign
     };
 
     /**
@@ -223,16 +221,16 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {object} requests an array of fired sinon requests
      * @param {object} options the options to provide to the response
      */
-    respond = function (requests, options) {
+    respond = function(requests, options) {
         var request = currentRequest(requests),
             statusCode = options.statusCode || 200,
             contentType = options.contentType || 'application/json',
             body = options.body || '';
         request.respond(statusCode,
-            { 'Content-Type': contentType },
-            contentType === 'application/json' ? JSON.stringify(body || {}) : body,
+            {'Content-Type': contentType},
+            contentType === 'application/json' ? JSON.stringify(body || {}) : body
         );
-        requests.currentIndex += 1;
+        requests.currentIndex += 1;  // eslint-disable-line no-param-reassign
     };
 
     /**
@@ -241,9 +239,9 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      * @param {object} requests an array of fired sinon requests
      * @param {object} body an object to be serialized to the response
      */
-    respondWithJson = function (requests, body) {
+    respondWithJson = function(requests, body) {
         respond(requests, {
-            body: body,
+            body: body
         });
     };
 
@@ -256,10 +254,10 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      *     (defaults to 500)
      * @param {object} body an object to be serialized to the response
      */
-    respondWithError = function (requests, statusCode, body) {
+    respondWithError = function(requests, statusCode, body) {
         respond(requests, {
             statusCode: statusCode || 500,
-            body: body,
+            body: body
         });
     };
 
@@ -271,11 +269,11 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      *     (defaults to 500)
      * @param {object} body the response body as a string
      */
-    respondWithTextError = function (requests, statusCode, body) {
+    respondWithTextError = function(requests, statusCode, body) {
         respond(requests, {
             statusCode: statusCode || 500,
             contentType: 'text/plain',
-            body: body,
+            body: body
         });
     };
 
@@ -284,9 +282,9 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
      *
      * @param {object} requests an array of fired sinon requests
      */
-    respondWithNoContent = function (requests) {
+    respondWithNoContent = function(requests) {
         respond(requests, {
-            statusCode: 204,
+            statusCode: 204
         });
     };
 
@@ -305,6 +303,6 @@ define(['sinon', 'underscore', 'URI'], function (sinon, _, URI) {
         respondWithJson: respondWithJson,
         respondWithError: respondWithError,
         respondWithTextError: respondWithTextError,
-        respondWithNoContent: respondWithNoContent,
+        respondWithNoContent: respondWithNoContent
     };
 });
diff --git a/src/js/utils/spec-helpers/spec-helpers.js b/src/js/utils/spec-helpers/spec-helpers.js
index 1e452ea7..05cf6c04 100644
--- a/src/js/utils/spec-helpers/spec-helpers.js
+++ b/src/js/utils/spec-helpers/spec-helpers.js
@@ -3,7 +3,7 @@
  *
  * @module SpecHelpers
  */
-define([], function () {
+define([], function() {
     'use strict';
 
     var withData, withConfiguration;
@@ -17,9 +17,9 @@ define([], function () {
      * is applied as arguments to func.
      * @param {function} func The function that actually expresses the logic of the test.
      */
-    withData = function (data, func) {
-        Object.keys(data).forEach(function (key) {
-            it(key, function () {
+    withData = function(data, func) {
+        Object.keys(data).forEach(function(key) {
+            it(key, function() {
                 func.apply(this, data[key]);
             });
         });
@@ -37,10 +37,10 @@ define([], function () {
      * @param {function} test The function that actually express the logic of the test.
      * May include it() or more describe().
      */
-    withConfiguration = function (config, setup, test) {
-        Object.keys(config).forEach(function (key) {
-            describe(key, function () {
-                beforeEach(function () {
+    withConfiguration = function(config, setup, test) {
+        Object.keys(config).forEach(function(key) {
+            describe(key, function() {
+                beforeEach(function() {
                     setup.apply(this, config[key]);
                 });
                 test();
@@ -50,6 +50,6 @@ define([], function () {
 
     return {
         withData: withData,
-        withConfiguration: withConfiguration,
+        withConfiguration: withConfiguration
     };
 });
diff --git a/src/js/utils/specs/ajax-helpers-spec.js b/src/js/utils/specs/ajax-helpers-spec.js
index 95f05bd6..90dc8a32 100644
--- a/src/js/utils/specs/ajax-helpers-spec.js
+++ b/src/js/utils/specs/ajax-helpers-spec.js
@@ -2,33 +2,33 @@ define(
     [
         'jquery',
         'sinon',
-        '../../utils/spec-helpers/ajax-helpers.js',
+        '../../utils/spec-helpers/ajax-helpers.js'
     ],
-    function ($, sinon, AjaxHelpers) {
+    function($, sinon, AjaxHelpers) {
         'use strict';
 
-        describe('AjaxHelpers', function () {
+        describe('AjaxHelpers', function() {
             var testUrl = 'https://example.com',
-                testData = { foo: 'bar', fizz: 'buzz' },
+                testData = {foo: 'bar', fizz: 'buzz'},
                 testQuerystring = $.param(testData);
 
-            describe('fakeServer', function () {
+            describe('fakeServer', function() {
                 var server = AjaxHelpers.server('foo');
                 var ajaxSpy = jasmine.createSpy('ajaxSpy');
 
                 $.ajax(testUrl).done(ajaxSpy);
                 server.respond();
 
-                it('responds with the contents of the first argument', function () {
+                it('responds with the contents of the first argument', function() {
                     expect(ajaxSpy).toHaveBeenCalledWith('foo', 'success', jasmine.any(Object));
                 });
             });
 
-            describe('fakeRequests', function () {
+            describe('fakeRequests', function() {
                 var requests = AjaxHelpers.requests();
                 $.ajax(testUrl);
 
-                it('returns an array that tracks fake requests', function () {
+                it('returns an array that tracks fake requests', function() {
                     // We're really already doing this already in all the tests that call AjaxHelpers.withFakeRequests
                     // down below, but Istanbul doesn't pick those up because they're not "in" a spec...
                     // so do a quick manual test.
@@ -39,148 +39,147 @@ define(
                 });
             });
 
-            describe('request helper', function () {
-                describe('expectRequest', function () {
-                    it('verifies a simple bodyless GET', AjaxHelpers.withFakeRequests(function (requests) {
+            describe('request helper', function() {
+                describe('expectRequest', function() {
+                    it('verifies a simple bodyless GET', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl);
                         AjaxHelpers.expectRequest(requests, 'GET', testUrl, undefined);
                     }));
 
-                    it('verifies a more complex request', AjaxHelpers.withFakeRequests(function (requests) {
+                    it('verifies a more complex request', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl, {
                             method: 'POST',
-                            data: 'foobar',
+                            data: 'foobar'
                         });
                         AjaxHelpers.expectRequest(requests, 'POST', testUrl, 'foobar');
                     }));
                 });
 
-                describe('expectNoRequests', function () {
-                    it('verifies 0 requests when none are made', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('expectNoRequests', function() {
+                    it('verifies 0 requests when none are made', AjaxHelpers.withFakeRequests(function(requests) {
                         AjaxHelpers.expectNoRequests(requests);
                     }));
 
-                    it('verifies 0 requests when all are handled', AjaxHelpers.withFakeRequests(function (requests) {
+                    it('verifies 0 requests when all are handled', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl);
                         AjaxHelpers.respondWithError(requests);
                         AjaxHelpers.expectNoRequests(requests);
                     }));
                 });
 
-                describe('expectJsonRequest', function () {
-                    it('validates a request with JSON payload', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('expectJsonRequest', function() {
+                    it('validates a request with JSON payload', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl, {
                             method: 'POST',
                             data: JSON.stringify(testData),
-                            contentType: 'application/json',
+                            contentType: 'application/json'
                         });
                         AjaxHelpers.expectJsonRequest(requests, 'POST', testUrl, testData);
                     }));
                 });
 
-                describe('expectRequestURL', function () {
-                    it('validates a JSON request made to a URL', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('expectRequestURL', function() {
+                    it('validates a JSON request made to a URL', AjaxHelpers.withFakeRequests(function(requests) {
                         var path = '/home/category';
 
-                        // eslint-disable-next-line prefer-template
                         $.ajax(testUrl + path + '?' + testQuerystring);
                         AjaxHelpers.expectRequestURL(requests, path, testData);
                     }));
                 });
 
-                describe('expectPostRequest', function () {
-                    it('validates a non-JSON POST request', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('expectPostRequest', function() {
+                    it('validates a non-JSON POST request', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl, {
                             method: 'POST',
-                            data: testQuerystring,
+                            data: testQuerystring
                         });
                         AjaxHelpers.expectPostRequest(requests, testUrl, testQuerystring);
                     }));
                 });
 
-                describe('skipResetRequest', function () {
-                    it('verifies request was cancelled', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('skipResetRequest', function() {
+                    it('verifies request was cancelled', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).abort();
                         AjaxHelpers.skipResetRequest(requests);
                     }));
                 });
             });
 
-            describe('response helper', function () {
+            describe('response helper', function() {
                 var ajaxSpy;
 
-                beforeEach(function () {
+                beforeEach(function() {
                     ajaxSpy = jasmine.createSpy('ajaxSpy');
                 });
 
-                describe('respondWithJson', function () {
-                    it('responds with JSON and code 200', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('respondWithJson', function() {
+                    it('responds with JSON and code 200', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).done(ajaxSpy);
                         AjaxHelpers.respondWithJson(requests, testData);
 
                         expect(ajaxSpy).toHaveBeenCalledWith(testData, 'success', jasmine.objectContaining({
                             responseJSON: testData,
-                            status: 200,
+                            status: 200
                         }));
                     }));
                 });
 
-                describe('respondWithError', function () {
-                    it('responds with JSON and code 500 by default', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('respondWithError', function() {
+                    it('responds with JSON and code 500 by default', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).fail(ajaxSpy);
                         AjaxHelpers.respondWithError(requests, null, testData);
 
                         expect(ajaxSpy).toHaveBeenCalledWith(jasmine.objectContaining({
                             responseJSON: testData,
-                            status: 500,
+                            status: 500
                         }), 'error', 'Internal Server Error');
                     }));
 
-                    it('responds with JSON and custom code', AjaxHelpers.withFakeRequests(function (requests) {
+                    it('responds with JSON and custom code', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).fail(ajaxSpy);
                         AjaxHelpers.respondWithError(requests, 555, testData);
 
                         expect(ajaxSpy).toHaveBeenCalledWith(jasmine.objectContaining({
                             responseJSON: testData,
-                            status: 555,
+                            status: 555
                         }), 'error', undefined);
                     }));
                 });
 
-                describe('respondWithTextError', function () {
-                    it('responds with text and code 500 by default', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('respondWithTextError', function() {
+                    it('responds with text and code 500 by default', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).fail(ajaxSpy);
                         AjaxHelpers.respondWithTextError(requests, null, 'foobar');
 
                         expect(ajaxSpy).toHaveBeenCalledWith(jasmine.objectContaining({
                             responseText: 'foobar',
-                            status: 500,
+                            status: 500
                         }), 'error', 'Internal Server Error');
                     }));
 
-                    it('responds with text and custom code', AjaxHelpers.withFakeRequests(function (requests) {
+                    it('responds with text and custom code', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).fail(ajaxSpy);
                         AjaxHelpers.respondWithTextError(requests, 555, 'foobar');
 
                         expect(ajaxSpy).toHaveBeenCalledWith(jasmine.objectContaining({
                             responseText: 'foobar',
-                            status: 555,
+                            status: 555
                         }), 'error', undefined);
                     }));
                 });
 
-                describe('respondWithNoContent', function () {
-                    it('responds with no body and code 204', AjaxHelpers.withFakeRequests(function (requests) {
+                describe('respondWithNoContent', function() {
+                    it('responds with no body and code 204', AjaxHelpers.withFakeRequests(function(requests) {
                         $.ajax(testUrl).done(ajaxSpy);
                         AjaxHelpers.respondWithNoContent(requests);
 
                         expect(ajaxSpy).toHaveBeenCalledWith(undefined, 'nocontent', jasmine.objectContaining({
                             responseJSON: {},
-                            status: 204,
+                            status: 204
                         }));
                     }));
                 });
             });
         });
-    },
+    }
 );
diff --git a/src/js/utils/specs/date-utils-spec.js b/src/js/utils/specs/date-utils-spec.js
index c487b7f1..02e88585 100644
--- a/src/js/utils/specs/date-utils-spec.js
+++ b/src/js/utils/specs/date-utils-spec.js
@@ -3,34 +3,34 @@ define(
         '../../utils/spec-helpers/spec-helpers.js',
         '../date-utils.js',
         'moment',
-        'moment-timezone',
+        'moment-timezone'
     ],
-    function (
+    function(
         SpecHelpers,
         DateUtils,
         moment,
-        momentTZ,
+        momentTZ
     ) {
         'use strict';
 
-        describe('DateUtils', function () {
-            beforeEach(function () {
+        describe('DateUtils', function() {
+            beforeEach(function() {
                 setFixtures('<div class="test"></div>');
             });
 
-            describe('stringToMoment', function () {
-                it('returns an empty string if provided no time', function () {
+            describe('stringToMoment', function() {
+                it('returns an empty string if provided no time', function() {
                     expect(DateUtils.stringToMoment()).toEqual(undefined);
                 });
-                it('converts a string to a moment.js object', function () {
+                it('converts a string to a moment.js object', function() {
                     expect(
-                        DateUtils.stringToMoment('2016-10-14 08:00:00+00:00').format('ll'),
+                        DateUtils.stringToMoment('2016-10-14 08:00:00+00:00').format('ll')
                     ).toEqual('Oct 14, 2016');
                 });
             });
 
-            describe('getSysTimezone', function () {
-                it('attempts to determine system timezone', function () {
+            describe('getSysTimezone', function() {
+                it('attempts to determine system timezone', function() {
                     // we need to determine the system tz offset from which to compare
                     var sysDate = new Date();
                     var sysDateOffset = sysDate.getTimezoneOffset();
@@ -39,17 +39,17 @@ define(
                 });
             });
 
-            describe('localizeTime', function () {
-                it('tests error conditions', function () {
+            describe('localizeTime', function() {
+                it('tests error conditions', function() {
                     expect(DateUtils.localizeTime()).toEqual('');
                 });
-                it('tests sys time determiner', function () {
+                it('tests sys time determiner', function() {
                     var testDate = DateUtils.stringToMoment('2016-10-14 08:00:00+00:00');
                     expect(
-                        moment(DateUtils.localizeTime(testDate).format()).isValid(),
-                    ).toBeTruthy();
+                         moment(DateUtils.localizeTime(testDate).format()).isValid()
+                         ).toBeTruthy();
                 });
-                it('offsets time according to a determined timezone', function () {
+                it('offsets time according to a determined timezone', function() {
                     var testDate = DateUtils.stringToMoment('2016-10-14 08:00:00+00:00');
                     // in order to avoid DST messes, we'll just pick some TZs without
                     var TestZones = {
@@ -57,91 +57,91 @@ define(
                         'Pacific/Honolulu': 'Oct 13, 2016 10:00 PM',
                         'Asia/Ho_Chi_Minh': 'Oct 14, 2016 3:00 PM',
                         'Atlantic/Reykjavik': 'Oct 14, 2016 8:00 AM',
-                        RANDOM_STRING: 'Oct 14, 2016 8:00 AM',
+                        RANDOM_STRING: 'Oct 14, 2016 8:00 AM'
                     };
-                    Object.keys(TestZones).forEach(function (key) {
+                    Object.keys(TestZones).forEach(function(key) {
                         expect(
-                            new DateUtils.localizeTime(testDate, key).format('lll'),
+                            new DateUtils.localizeTime(testDate, key).format('lll')
                         ).toEqual(TestZones[key]);
                     });
                 });
             });
 
-            describe('localize', function () {
-                it('tests error conditions', function () {
+            describe('localize', function() {
+                it('tests error conditions', function() {
                     var context = {};
                     expect(
-                        DateUtils.localize(context),
+                        DateUtils.localize(context)
                     ).toEqual('');
                     context = {
                         datetime: 'RANDOM_STRING',
                         timezone: 'RANDOM_STRING',
-                        language: 'RANDOM_STRING',
+                        language: 'RANDOM_STRING'
                     };
                     expect(DateUtils.localize(context)).toEqual('');
                 });
-                it('tests defaults', function () {
+                it('tests defaults', function() {
                     var context = {
                         datetime: '2016-10-14 08:00:00+00:00',
                         timezone: 'RANDOM_STRING',
-                        language: 'RANDOM_STRING',
+                        language: 'RANDOM_STRING'
                     };
                     expect(DateUtils.localize(context)).toEqual('Oct 14, 2016 08:00 UTC');
                 });
 
-                it('generates a localized string based on a language preference', function () {
+                it('generates a localized string based on a language preference', function() {
                     var TestLangs = {
                         en: 'Oct 14, 2016 08:00 UTC',
                         ru: '14 окт. 2016 г. 08:00 UTC',
-                        ar: '١٤ أكتوبر ٢٠١٦ ٠٨:٠٠ UTC',
+                        ar: '١٤ أكتوبر ٢٠١٦ ٠٨:٠٠ UTC'
                     };
-                    Object.keys(TestLangs).forEach(function (key) {
+                    Object.keys(TestLangs).forEach(function(key) {
                         var context = {
                             datetime: '2016-10-14 08:00:00+00:00',
                             timezone: 'UTC',
-                            language: key,
+                            language: key
                         };
                         expect(DateUtils.localize(context)).toEqual(TestLangs[key]);
                     });
                 });
-                it('checks for formatting', function () {
+                it('checks for formatting', function() {
                     var TestFormats = {
                         time: '8:00:00 AM UTC',
                         shortDate: 'Oct 14, 2016',
                         longDate: 'Friday, October 14, 2016 8:00 AM',
-                        undefined: 'Oct 14, 2016 08:00 UTC',
+                        undefined: 'Oct 14, 2016 08:00 UTC'
                     };
-                    Object.keys(TestFormats).forEach(function (key) {
+                    Object.keys(TestFormats).forEach(function(key) {
                         var context = {
                             datetime: '2016-10-14 08:00:00+00:00',
                             timezone: 'UTC',
                             language: 'en',
-                            format: DateUtils.dateFormatEnum[key],
+                            format: DateUtils.dateFormatEnum[key]
                         };
                         expect(DateUtils.localize(context)).toEqual(TestFormats[key]);
                     });
                 });
 
-                it('generates a localized datetime string', function () {
+                it('generates a localized datetime string', function() {
                     var context = {
                         datetime: '2016-10-14 08:00:00+00:00',
-                        timezone: 'Atlantic/Azores',
+                        timezone: 'Atlantic/Azores'
                     };
                     expect(DateUtils.localize(context)).toEqual('Oct 14, 2016 08:00 +00');
                 });
 
-                it('generates a more complex localized datetime string', function () {
+                it('generates a more complex localized datetime string', function() {
                     var context = {
                         datetime: '2016-10-14 08:00:00+00:00',
                         timezone: 'Pacific/Kiritimati',
                         language: 'ar',
-                        format: DateUtils.dateFormatEnum.longDate,
+                        format: DateUtils.dateFormatEnum.longDate
                     };
                     expect(
-                        DateUtils.localize(context),
+                        DateUtils.localize(context)
                     ).toEqual('الجمعة ١٤ أكتوبر ٢٠١٦ ٢٢:٠٠');
                 });
             });
         });
-    },
+    }
 );
diff --git a/src/js/utils/specs/global-loader-spec.js b/src/js/utils/specs/global-loader-spec.js
index 516fdf66..be1ff108 100644
--- a/src/js/utils/specs/global-loader-spec.js
+++ b/src/js/utils/specs/global-loader-spec.js
@@ -1,44 +1,44 @@
 /* global $, _ */
 define(
     [
-        'edx-ui-toolkit/js/utils/global-loader',
+        'edx-ui-toolkit/js/utils/global-loader'
     ],
-    function (GlobalLoader) {
+    function(GlobalLoader) {
         'use strict';
 
-        describe('GlobalLoader', function () {
-            beforeEach(function () {
+        describe('GlobalLoader', function() {
+            beforeEach(function() {
                 GlobalLoader.defineAs('TestModule', 'js/test-module')(
                     [],
-                    function () {
-                        return { name: 'TestModule' };
-                    },
+                    function() {
+                        return {name: 'TestModule'};
+                    }
                 );
             });
 
-            it('installs a module into the edx namespace', function () {
+            it('installs a module into the edx namespace', function() {
                 expect(edx.TestModule).toBeDefined();
                 expect(edx.TestModule.name).toBe('TestModule');
             });
 
-            it('handles standard libraries', function () {
+            it('handles standard libraries', function() {
                 GlobalLoader.defineAs('TestModule2', 'js/test-module2')(
                     ['jquery', 'underscore'],
-                    function ($, _) {
-                        return { name: 'TestModule2', $: $, _: _ };
-                    },
+                    function($, _) {
+                        return {name: 'TestModule2', $: $, _: _};
+                    }
                 );
                 expect(edx.TestModule2).toBeDefined();
                 expect(edx.TestModule2.$).toBe($);
                 expect(edx.TestModule2._).toBe(_);
             });
 
-            it('loads dependent modules', function () {
+            it('loads dependent modules', function() {
                 GlobalLoader.defineAs('TestModule2', 'js/test-module2')(
                     ['js/test-module'],
-                    function (TestModule) {
-                        return { name: 'TestModule2', dependsOn: TestModule };
-                    },
+                    function(TestModule) {
+                        return {name: 'TestModule2', dependsOn: TestModule};
+                    }
                 );
 
                 expect(edx.TestModule2).toBeDefined();
@@ -46,5 +46,5 @@ define(
                 expect(edx.TestModule2.dependsOn).toBe(edx.TestModule);
             });
         });
-    },
+    }
 );
diff --git a/src/js/utils/specs/html-utils-spec.js b/src/js/utils/specs/html-utils-spec.js
index c518d7ec..94516d2b 100644
--- a/src/js/utils/specs/html-utils-spec.js
+++ b/src/js/utils/specs/html-utils-spec.js
@@ -2,190 +2,190 @@ define(
     [
         'jquery',
         '../../utils/spec-helpers/spec-helpers.js',
-        '../html-utils.js',
+        '../html-utils.js'
     ],
-    function ($, SpecHelpers, HtmlUtils) {
+    function($, SpecHelpers, HtmlUtils) {
         'use strict';
 
-        describe('HtmlUtils', function () {
-            beforeEach(function () {
+        describe('HtmlUtils', function() {
+            beforeEach(function() {
                 setFixtures('<div class="test"></div>');
             });
 
-            describe('HtmlSnippet', function () {
-                it('can convert to a string', function () {
+            describe('HtmlSnippet', function() {
+                it('can convert to a string', function() {
                     expect(new HtmlUtils.HtmlSnippet('Hello, world').toString()).toBe('Hello, world');
                 });
             });
 
-            describe('HTML', function () {
-                it('returns an HTML snippet', function () {
+            describe('HTML', function() {
+                it('returns an HTML snippet', function() {
                     expect(HtmlUtils.HTML('Hello, world') instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                 });
             });
 
-            describe('ensureHtml', function () {
+            describe('ensureHtml', function() {
                 SpecHelpers.withData({
                     'HTML escapes text strings': [
                         'Rock & Roll',
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'HTML escapes full HTML strings': [
                         '<a href="world">Rock &amp; Roll</a>',
-                        '&lt;a href=&quot;world&quot;&gt;Rock &amp;amp; Roll&lt;/a&gt;',
+                        '&lt;a href=&quot;world&quot;&gt;Rock &amp;amp; Roll&lt;/a&gt;'
                     ],
                     'does not escape HTML snippets': [
                         HtmlUtils.HTML('<a href="world">Rock &amp; Roll</a>'),
-                        '<a href="world">Rock &amp; Roll</a>',
-                    ],
-                }, function (input, expectedString) {
+                        '<a href="world">Rock &amp; Roll</a>'
+                    ]
+                }, function(input, expectedString) {
                     var result = HtmlUtils.ensureHtml(input);
                     expect(result instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                     expect(result.toString()).toEqual(expectedString);
                 });
             });
 
-            describe('interpolateHtml', function () {
-                it('can interpolate a string with no parameters provided', function () {
+            describe('interpolateHtml', function() {
+                it('can interpolate a string with no parameters provided', function() {
                     expect(HtmlUtils.interpolateHtml('Hello, world').toString()).toEqual(
-                        'Hello, world',
+                        'Hello, world'
                     );
                 });
 
                 SpecHelpers.withData({
                     'can interpolate a string with empty parameters': [
                         'Hello, world', {},
-                        'Hello, world',
+                        'Hello, world'
                     ],
                     'can interpolate a string with one parameter': [
-                        'Hello, {name}', { name: 'Andy' },
-                        'Hello, Andy',
+                        'Hello, {name}', {name: 'Andy'},
+                        'Hello, Andy'
                     ],
                     'does not interpolate additional curly braces': [
-                        'Hello, {name}. Here is a { followed by a }', { name: 'Andy' },
-                        'Hello, Andy. Here is a { followed by a }',
+                        'Hello, {name}. Here is a { followed by a }', {name: 'Andy'},
+                        'Hello, Andy. Here is a { followed by a }'
                     ],
                     'escapes characters in the template': [
                         'Rock & Roll', {},
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'does not escape HTML parameters': [
-                        'Hello, {anchor}', { anchor: HtmlUtils.HTML('<a href="world">world</a>') },
-                        'Hello, <a href="world">world</a>',
+                        'Hello, {anchor}', {anchor: HtmlUtils.HTML('<a href="world">world</a>')},
+                        'Hello, <a href="world">world</a>'
                     ],
                     'escapes characters in parameters': [
-                        'I love {name}', { name: 'Rock & Roll' },
-                        'I love Rock &amp; Roll',
+                        'I love {name}', {name: 'Rock & Roll'},
+                        'I love Rock &amp; Roll'
                     ],
                     'does not double escape when chaining interpolate calls': [
-                        'I love {name}', { name: HtmlUtils.interpolateHtml('Rock & Roll') },
-                        'I love Rock &amp; Roll',
+                        'I love {name}', {name: HtmlUtils.interpolateHtml('Rock & Roll')},
+                        'I love Rock &amp; Roll'
                     ],
                     'full example': [
                         'You are enrolling in {spanStart}{courseName}{spanEnd}',
                         {
                             courseName: 'Rock & Roll',
                             spanStart: HtmlUtils.HTML('<span class="course-title">'),
-                            spanEnd: HtmlUtils.HTML('</span>'),
+                            spanEnd: HtmlUtils.HTML('</span>')
                         },
-                        'You are enrolling in <span class="course-title">Rock &amp; Roll</span>',
-                    ],
-                }, function (template, options, expectedString) {
+                        'You are enrolling in <span class="course-title">Rock &amp; Roll</span>'
+                    ]
+                }, function(template, options, expectedString) {
                     var result = HtmlUtils.interpolateHtml(template, options);
                     expect(result instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                     expect(result.toString()).toEqual(expectedString);
                 });
             });
 
-            describe('joinHtml', function () {
+            describe('joinHtml', function() {
                 SpecHelpers.withData({
                     'can join a single string': [
                         ['Hello, world'],
-                        'Hello, world',
+                        'Hello, world'
                     ],
                     'escapes characters provided as strings': [
                         ['Rock & Roll'],
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'does not escape HTML snippets': [
                         [HtmlUtils.HTML('<a href="world">world</a>')],
-                        '<a href="world">world</a>',
+                        '<a href="world">world</a>'
                     ],
                     'can join a mixture of strings and HTML snippets': [
                         ['Rock & Roll', ' all over the ', HtmlUtils.HTML('<a href="world">world</a>')],
-                        'Rock &amp; Roll all over the <a href="world">world</a>',
-                    ],
-                }, function (items, expectedString) {
+                        'Rock &amp; Roll all over the <a href="world">world</a>'
+                    ]
+                }, function(items, expectedString) {
                     var result = HtmlUtils.joinHtml.apply(null, items);
                     expect(result instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                     expect(result.toString()).toEqual(expectedString);
                 });
             });
 
-            describe('template', function () {
-                it('can render a template with no parameters', function () {
+            describe('template', function() {
+                it('can render a template with no parameters', function() {
                     var template = HtmlUtils.template('Hello, world'),
                         result = template();
                     expect(result instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                     expect(result.toString()).toEqual('Hello, world');
                 });
 
-                it('can render a template with parameters', function () {
+                it('can render a template with parameters', function() {
                     var template = HtmlUtils.template('Hello, <%- name %>'),
-                        result = template({ name: 'world' });
+                        result = template({name: 'world'});
                     expect(result instanceof HtmlUtils.HtmlSnippet).toBeTruthy();
                     expect(result.toString()).toEqual('Hello, world');
                 });
 
-                it('adds HtmlUtils as an additional context variable for the template', function () {
+                it('adds HtmlUtils as an additional context variable for the template', function() {
                     var template = HtmlUtils.template('I love <%= HtmlUtils.ensureHtml("Rock & Roll") %>');
                     expect(template().toString()).toEqual('I love Rock &amp; Roll');
                 });
 
-                it('adds StringUtils as an additional context variable for the template', function () {
+                it('adds StringUtils as an additional context variable for the template', function() {
                     var template = HtmlUtils.template(
-                        '<%= StringUtils.interpolate("Hello, {name}", {name: "world"}) %>',
+                        '<%= StringUtils.interpolate("Hello, {name}", {name: "world"}) %>'
                     );
                     expect(template().toString()).toEqual('Hello, world');
                 });
             });
 
-            describe('setHtml', function () {
+            describe('setHtml', function() {
                 SpecHelpers.withData({
                     'HTML escapes text strings': [
                         'Rock & Roll',
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'HTML escapes full HTML strings': [
                         '<a href="world">Rock &amp; Roll</a>',
-                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;',
+                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;'
                     ],
                     'does not escape HTML snippets': [
                         HtmlUtils.HTML('<a href="world">Rock &amp; Roll</a>'),
-                        '<a href="world">Rock &amp; Roll</a>',
-                    ],
-                }, function (input, expectedString) {
+                        '<a href="world">Rock &amp; Roll</a>'
+                    ]
+                }, function(input, expectedString) {
                     var $element = $('.test');
                     HtmlUtils.setHtml($element, input);
                     expect($element.html()).toEqual(expectedString);
                 });
             });
 
-            describe('append', function () {
+            describe('append', function() {
                 SpecHelpers.withData({
                     'HTML escapes text strings': [
                         'Rock & Roll',
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'HTML escapes full HTML strings': [
                         '<a href="world">Rock &amp; Roll</a>',
-                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;',
+                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;'
                     ],
                     'does not escape HTML snippets': [
                         HtmlUtils.HTML('<a href="world">Rock &amp; Roll</a>'),
-                        '<a href="world">Rock &amp; Roll</a>',
-                    ],
-                }, function (input, expectedString) {
+                        '<a href="world">Rock &amp; Roll</a>'
+                    ]
+                }, function(input, expectedString) {
                     var $element = $('.test');
 
                     // Appends correctly with no children
@@ -195,26 +195,25 @@ define(
                     // Appends correctly with a pre-existing child
                     $element.html('<p>Hello, world</p>');
                     HtmlUtils.append($element, input);
-                    // eslint-disable-next-line prefer-template
                     expect($element.html()).toEqual('<p>Hello, world</p>' + expectedString);
                 });
             });
 
-            describe('prepend', function () {
+            describe('prepend', function() {
                 SpecHelpers.withData({
                     'HTML escapes text strings': [
                         'Rock & Roll',
-                        'Rock &amp; Roll',
+                        'Rock &amp; Roll'
                     ],
                     'HTML escapes full HTML strings': [
                         '<a href="world">Rock &amp; Roll</a>',
-                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;',
+                        '&lt;a href="world"&gt;Rock &amp;amp; Roll&lt;/a&gt;'
                     ],
                     'does not escape HTML snippets': [
                         HtmlUtils.HTML('<a href="world">Rock &amp; Roll</a>'),
-                        '<a href="world">Rock &amp; Roll</a>',
-                    ],
-                }, function (input, expectedString) {
+                        '<a href="world">Rock &amp; Roll</a>'
+                    ]
+                }, function(input, expectedString) {
                     var $element = $('.test');
 
                     // Prepends correctly with no children
@@ -224,10 +223,9 @@ define(
                     // Prepends correctly with a pre-existing child
                     $element.html('<p>Hello, world</p>');
                     HtmlUtils.prepend($element, input);
-                    // eslint-disable-next-line prefer-template
                     expect($element.html()).toEqual(expectedString + '<p>Hello, world</p>');
                 });
             });
         });
-    },
+    }
 );
diff --git a/src/js/utils/specs/string-utils-spec.js b/src/js/utils/specs/string-utils-spec.js
index fcd557d5..29d08447 100644
--- a/src/js/utils/specs/string-utils-spec.js
+++ b/src/js/utils/specs/string-utils-spec.js
@@ -1,41 +1,41 @@
 define(
     [
         '../../utils/spec-helpers/spec-helpers.js',
-        '../string-utils.js',
+        '../string-utils.js'
     ],
-    function (SpecHelpers, StringUtils) {
+    function(SpecHelpers, StringUtils) {
         'use strict';
 
-        describe('StringUtils', function () {
-            describe('interpolate', function () {
-                it('can interpolate a string with no parameters provided', function () {
+        describe('StringUtils', function() {
+            describe('interpolate', function() {
+                it('can interpolate a string with no parameters provided', function() {
                     expect(StringUtils.interpolate('Hello, world')).toEqual(
-                        'Hello, world',
+                        'Hello, world'
                     );
                 });
 
                 SpecHelpers.withData({
                     'can interpolate a string with empty parameters': [
                         'Hello, world', {},
-                        'Hello, world',
+                        'Hello, world'
                     ],
                     'can interpolate a string with one parameter': [
-                        'Hello, {name}', { name: 'Andy' },
-                        'Hello, Andy',
+                        'Hello, {name}', {name: 'Andy'},
+                        'Hello, Andy'
                     ],
                     'does not interpolate additional curly braces': [
-                        'Hello, {name}. Here is a { followed by a }', { name: 'Andy' },
-                        'Hello, Andy. Here is a { followed by a }',
+                        'Hello, {name}. Here is a { followed by a }', {name: 'Andy'},
+                        'Hello, Andy. Here is a { followed by a }'
                     ],
                     'does not escape html': [
-                        '<b>Hello</b>, {name}', { name: '<script>alert("boom");</script>' },
-                        '<b>Hello</b>, <script>alert("boom");</script>',
-                    ],
-                }, function (template, options, expectedString) {
+                        '<b>Hello</b>, {name}', {name: '<script>alert("boom");</script>'},
+                        '<b>Hello</b>, <script>alert("boom");</script>'
+                    ]
+                }, function(template, options, expectedString) {
                     var result = StringUtils.interpolate(template, options);
                     expect(result).toEqual(expectedString);
                 });
             });
         });
-    },
+    }
 );
diff --git a/src/js/utils/string-utils.js b/src/js/utils/string-utils.js
index e9442df6..c47170c3 100644
--- a/src/js/utils/string-utils.js
+++ b/src/js/utils/string-utils.js
@@ -3,10 +3,10 @@
  *
  * @module StringUtils
  */
-(function (define) {
+(function(define) {
     'use strict';
 
-    define([], function () {
+    define([], function() {
         var interpolate;
 
         /**
@@ -53,16 +53,16 @@
          * @param {Object} parameters An optional set of parameters to the template.
          * @returns {string} A string with the values interpolated.
          */
-        interpolate = function (formatString, parameters) {
+        interpolate = function(formatString, parameters) {
             return formatString.replace(/{\w+}/g,
-                function (parameter) {
+                function(parameter) {
                     var parameterName = parameter.slice(1, -1);
                     return String(parameters[parameterName]);
                 });
         };
 
         return {
-            interpolate: interpolate,
+            interpolate: interpolate
         };
     });
 }).call(
@@ -72,7 +72,7 @@
     // 2. If not, use 'RequireJS.define' if that is available
     // 3. else use the GlobalLoader to install the class into the edx namespace
     // eslint-disable-next-line no-nested-ternary
-    typeof define === 'function' && define.amd ? define
-        : (typeof RequireJS !== 'undefined' ? RequireJS.define
-            : edx.GlobalLoader.defineAs('StringUtils', 'edx-ui-toolkit/js/utils/string-utils')),
+    typeof define === 'function' && define.amd ? define :
+        (typeof RequireJS !== 'undefined' ? RequireJS.define :
+            edx.GlobalLoader.defineAs('StringUtils', 'edx-ui-toolkit/js/utils/string-utils'))
 );
diff --git a/test/karma.ci.conf.js b/test/karma.ci.conf.js
index bd6eb1ae..257e009e 100644
--- a/test/karma.ci.conf.js
+++ b/test/karma.ci.conf.js
@@ -1,7 +1,7 @@
 var baseConfig = require('./karma.conf');
 
 // Karma configuration to run in CI
-module.exports = function (config) {
+module.exports = function(config) {
     'use strict';
 
     baseConfig(config, {
@@ -10,14 +10,14 @@ module.exports = function (config) {
         customLaunchers: {
             Chrome_github_ci: {
                 base: 'Chrome',
-                flags: ['--no-sandbox'],
-            },
+                flags: ['--no-sandbox']
+            }
         },
         browsers: ['Chrome_github_ci', 'Firefox', 'ChromeHeadless'],
         logLevel: config.LOG_INFO,
         preprocessors: {
-            'src/js/**/*.js': ['coverage'],
+            'src/js/**/*.js': ['coverage']
         },
-        reporters: ['spec', 'coverage', 'coveralls'],
+        reporters: ['spec', 'coverage', 'coveralls']
     });
 };
diff --git a/test/karma.conf.js b/test/karma.conf.js
index 67a71abf..de3a5abf 100644
--- a/test/karma.conf.js
+++ b/test/karma.conf.js
@@ -4,7 +4,7 @@ const puppeteer = require('puppeteer');
 
 process.env.CHROME_BIN = puppeteer.executablePath();
 
-module.exports = function (config, overrideOptions) {
+module.exports = function(config, overrideOptions) {
     'use strict';
 
     var options;
@@ -20,9 +20,9 @@ module.exports = function (config, overrideOptions) {
             browsers: ['ChromeHeadless'],
             logLevel: config.LOG_INFO,
             preprocessors: {
-                'src/js/**/*.js': ['coverage'],
+                'src/js/**/*.js': ['coverage']
             },
-            reporters: ['spec', 'coverage'],
+            reporters: ['spec', 'coverage']
         };
     }
 
@@ -34,7 +34,7 @@ module.exports = function (config, overrideOptions) {
         // support the namespace 'edx-ui-toolkit' so that it can be used in the
         // same way as clients expect to see it.
         proxies: {
-            '/base/edx-ui-toolkit/': '/base/src/',
+            '/base/edx-ui-toolkit/': '/base/src/'
         },
 
         // frameworks to use
@@ -49,22 +49,22 @@ module.exports = function (config, overrideOptions) {
             // load the RequireJS configuration
             'test/require-config.js',
 
-            // load third party libraries
+           // load third party libraries
             'node_modules/underscore/underscore.js',
 
             // register third party libraries to be loaded via RequireJS
-            { pattern: 'node_modules/backbone/backbone.js', included: false },
-            { pattern: 'node_modules/backbone.paginator/lib/backbone.paginator.js', included: false },
-            { pattern: 'node_modules/requirejs-text/text.js', included: false },
-            { pattern: 'node_modules/sinon/**/*.js', included: false },
-            { pattern: 'node_modules/urijs/src/*.js', included: false },
-            { pattern: 'node_modules/moment/min/moment-with-locales.min.js', included: false },
-            { pattern: 'node_modules/moment-timezone/builds/moment-timezone-with-data.js', included: false },
-            { pattern: 'test/jquery.simulate.js', included: false },
+            {pattern: 'node_modules/backbone/backbone.js', included: false},
+            {pattern: 'node_modules/backbone.paginator/lib/backbone.paginator.js', included: false},
+            {pattern: 'node_modules/requirejs-text/text.js', included: false},
+            {pattern: 'node_modules/sinon/**/*.js', included: false},
+            {pattern: 'node_modules/urijs/src/*.js', included: false},
+            {pattern: 'node_modules/moment/min/moment-with-locales.min.js', included: false},
+            {pattern: 'node_modules/moment-timezone/builds/moment-timezone-with-data.js', included: false},
+            {pattern: 'test/jquery.simulate.js', included: false},
 
             // register all the UI Toolkit source and Underscore templates
-            { pattern: 'src/js/**/*.js', included: false },
-            { pattern: 'src/js/**/*.underscore', included: false },
+            {pattern: 'src/js/**/*.js', included: false},
+            {pattern: 'src/js/**/*.underscore', included: false}
         ],
 
         // plugins required for running the karma tests
@@ -78,7 +78,7 @@ module.exports = function (config, overrideOptions) {
             'karma-coveralls',
             'karma-sinon',
             'karma-jasmine-html-reporter',
-            'karma-spec-reporter',
+            'karma-spec-reporter'
         ],
 
         // preprocess each file according to the specified options
@@ -91,10 +91,10 @@ module.exports = function (config, overrideOptions) {
             dir: 'build',
             subdir: 'coverage-js',
             reporters: [
-                { type: 'html', subdir: 'coverage-js/html' },
-                { type: 'cobertura', file: 'coverage.xml' },
-                { type: 'lcov', dir: 'coverage/' },
-            ],
+                {type: 'html', subdir: 'coverage-js/html'},
+                {type: 'cobertura', file: 'coverage.xml'},
+                {type: 'lcov', dir: 'coverage/'}
+            ]
         },
 
         // web server port
@@ -123,6 +123,6 @@ module.exports = function (config, overrideOptions) {
 
         // Continuous Integration mode
         // if true, Karma captures browsers, runs the tests and exits
-        singleRun: options.singleRun,
+        singleRun: options.singleRun
     });
 };
diff --git a/test/karma.debug.conf.js b/test/karma.debug.conf.js
index 0d5774f5..fde16ac1 100644
--- a/test/karma.debug.conf.js
+++ b/test/karma.debug.conf.js
@@ -1,7 +1,7 @@
 var baseConfig = require('./karma.conf');
 
 // Karma configuration for debugging
-module.exports = function (config) {
+module.exports = function(config) {
     'use strict';
 
     baseConfig(config, {
@@ -10,6 +10,6 @@ module.exports = function (config) {
         browsers: ['Chrome'],
         logLevel: baseConfig.LOG_DEBUG,
         preprocessors: [],
-        reporters: ['kjhtml'],
+        reporters: ['kjhtml']
     });
 };
diff --git a/test/require-config.js b/test/require-config.js
index bee31e85..0b45f632 100644
--- a/test/require-config.js
+++ b/test/require-config.js
@@ -20,33 +20,33 @@ require.config({
         URI: 'node_modules/urijs/src/URI',
         IPv6: 'node_modules/urijs/src/IPv6',
         punycode: 'node_modules/urijs/src/punycode',
-        SecondLevelDomains: 'node_modules/urijs/src/SecondLevelDomains',
+        SecondLevelDomains: 'node_modules/urijs/src/SecondLevelDomains'
     },
     wrapShim: true,
     shim: {
         jquery: {
-            exports: '$',
+            exports: '$'
         },
         backbone: {
             deps: ['underscore', 'jquery'],
             exports: 'Backbone',
-            init: function (_, $) {
+            init: function(_, $) {
                 'use strict';
 
                 var Backbone;
                 Backbone.$ = $;
                 return Backbone;
-            },
+            }
         },
         'jquery.simulate': {
             deps: ['jquery'],
-            exports: ['$.simulate'],
+            exports: ['$.simulate']
         },
         underscore: {
-            exports: '_',
+            exports: '_'
         },
         'edx-ui-toolkit/js/utils/global-loader': {
-            exports: 'edx.GlobalLoader',
-        },
-    },
+            exports: 'edx.GlobalLoader'
+        }
+    }
 });
diff --git a/test/spec-runner.js b/test/spec-runner.js
index a76c0f75..1d5df419 100644
--- a/test/spec-runner.js
+++ b/test/spec-runner.js
@@ -5,14 +5,14 @@
  * This is where your tests go.  It should happen automatically when you
  * add files to the karma configuration.
  */
-(function () {
+(function() {
     'use strict';
 
     var specs = [],
         config = {};
 
     // you can automatically get the test files using karma's configs
-    Object.keys(window.__karma__.files).forEach(function (file) {
+    Object.keys(window.__karma__.files).forEach(function(file) {
         if (/spec\.js$/.test(file)) {
             specs.push(file);
         }
diff --git a/webpack.config.js b/webpack.config.js
index 04ce9bbc..00672817 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -2,7 +2,7 @@ var path = require('path'),
     Webpack = require('webpack'),
     MiniCssExtractPlugin = require('mini-css-extract-plugin');
 
-(function () {
+(function() {
     'use strict';
 
     var outputRoot = process.env.OUTPUT_ROOT ? process.env.OUTPUT_ROOT : 'doc/public/',
@@ -13,12 +13,12 @@ var path = require('path'),
     module.exports = {
         entry: [
             path.resolve(__dirname, './doc/static/js/ui-toolkit-doc-factory.js'),
-            path.resolve(__dirname, './doc/static/sass/main-ltr.scss'),
+            path.resolve(__dirname, './doc/static/sass/main-ltr.scss')
         ],
         output: {
             path: path.resolve(__dirname, outputRoot),
             publicPath: siteRoot + publicStaticRoot,
-            filename: 'ui-toolkit-doc-factory.js',
+            filename: 'ui-toolkit-doc-factory.js'
         },
         resolve: {
             alias: {
@@ -26,9 +26,9 @@ var path = require('path'),
                 modernizr: 'edx-pattern-library/js/modernizr-custom',
                 'edx-pattern-library': patternLibraryPath,
                 'edx-ui-toolkit': path.resolve(__dirname, 'src'),
-                doc: path.resolve(__dirname, 'doc/static'),
+                doc: path.resolve(__dirname, 'doc/static')
             },
-            modules: ['node_modules'],
+            modules: ['node_modules']
         },
         module: {
             rules: [
@@ -36,41 +36,42 @@ var path = require('path'),
                     test: /\.scss$/,
                     use: [
                         {
-                            loader: MiniCssExtractPlugin.loader,
+                            loader: MiniCssExtractPlugin.loader
                         },
                         {
                             loader: 'css-loader',
                             options: {
-                                url: false,
-                            },
+                                url: false
+                            }
                         },
                         {
                             loader: 'sass-loader',
                             options: {
                                 sassOptions: {
                                     includePaths: [
-                                        path.resolve(__dirname, './node_modules'),
-                                    ],
+                                        path.resolve(__dirname, './node_modules')
+                                    ]
                                 },
-                                additionalData: `$pattern-library-path: '${siteRoot}./public/edx-pattern-library' !default;`,
-                            },
-                        },
-                    ],
-                },
-            ],
+                                additionalData: '$pattern-library-path: \'' + siteRoot +
+                                                        './public/edx-pattern-library\' !default;'
+                            }
+                        }
+                    ]
+                }
+            ]
         },
         plugins: [
             new Webpack.ProvidePlugin({
-                $: 'jquery',
+                $: 'jquery'
             }),
-            new Webpack.IgnorePlugin({ resourceRegExp: /^(config.js)$/ }),
+            new Webpack.IgnorePlugin({resourceRegExp: /^(config.js)$/}),
             new Webpack.LoaderOptionsPlugin({
-                debug: true,
+                debug: true
             }),
             new MiniCssExtractPlugin({
-                filename: 'ui-toolkit.css',
-            }),
+                filename: 'ui-toolkit.css'
+            })
         ],
-        devtool: 'inline-source-map',
+        devtool: 'inline-source-map'
     };
 }());