From 82dc007493f122f619682d8ab5fc37948f90ffaa Mon Sep 17 00:00:00 2001
From: Martii <thalamew@hotmail.com>
Date: Tue, 15 Jul 2014 14:25:21 -0600
Subject: [PATCH] Should be done with minimal breakage... testing phase now.

Applies to #264
---
 libs/collectiveRating.js                      |  38 +--
 libs/flag.js                                  | 118 ++++----
 libs/githubClient.js                          |  72 ++---
 libs/helpers.js                               |  58 ++--
 libs/markdown.js                              |  42 +--
 libs/modelParser.js                           | 162 +++++-----
 libs/modelQuery.js                            | 158 +++++-----
 libs/modelsList.js                            | 286 +++++++++---------
 libs/modifySessions.js                        |  88 +++---
 libs/muExpress.js                             |  20 +-
 libs/passportLoader.js                        |  20 +-
 libs/passportVerify.js                        |  58 ++--
 libs/remove.js                                |  94 +++---
 libs/repoManager.js                           | 122 ++++----
 libs/tasks.js                                 |  40 +--
 libs/templateHelpers.js                       |  80 ++---
 .../includes/scripts/commentReplyScript.html  |  20 +-
 views/includes/scripts/tableTrLinkScript.html |   6 +-
 views/pages/scriptEditMetadataPage.html       |  18 +-
 views/scriptEdit.html                         |  20 +-
 20 files changed, 762 insertions(+), 758 deletions(-)

diff --git a/libs/collectiveRating.js b/libs/collectiveRating.js
index 72c03f999..dd271546b 100644
--- a/libs/collectiveRating.js
+++ b/libs/collectiveRating.js
@@ -2,34 +2,34 @@
 
 var Script = require('../models/script').Script;
 
-function median(values) {
-  var middle = Math.floor(values.length / 2);
-  values.sort(function (a, b) { return a - b; });
+function median(aValues) {
+  var middle = Math.floor(aValues.length / 2);
+  aValues.sort(function (aA, aB) { return aA - aB; });
 
-  return values.length % 2 ? values[middle] :
-    (values[middle - 1] + values[middle]) / 2;
+  return aValues.length % 2 ? aValues[middle] :
+    (aValues[middle - 1] + aValues[middle]) / 2;
 }
 
-function mean(values) {
+function mean(aValues) {
   var sum = 0;
   var i = 0;
-  for (; i < values.length; ++i) {
-    sum += values[i];
+  for (; i < aValues.length; ++i) {
+    sum += aValues[i];
   }
 
-  return sum / values.length;
+  return sum / aValues.length;
 }
 
 // Generate a collective rating by averaging the median and mean of
 // scripts in a group. I think this gives a more fair rating than just
 // using one of them alone.
-function getRating(scripts) {
+function getRating(aScripts) {
   var ratings = null;
 
-  if (scripts.length < 2) { return 0; }
+  if (aScripts.length < 2) { return 0; }
 
-  ratings = scripts.map(function (script) {
-    return script.rating;
+  ratings = aScripts.map(function (aScript) {
+    return aScript.rating;
   });
 
   return Math.round((median(ratings) + mean(ratings)) / 2);
@@ -39,15 +39,15 @@ exports.getRating = getRating;
 // TODO: Memoize this function with an
 // expiring cache (either memory or DB based) to
 // speed up voting and flagging
-exports.getKarma = function (user, maxKarma, callback) {
+exports.getKarma = function (aUser, aMaxKarma, aCallback) {
   var ratings = [];
   var karma = 0;
-  Script.find({ _authorId: user._id }, 'rating', function (err, scripts) {
-    if (err) { return callback(karma); }
+  Script.find({ _authorId: aUser._id }, 'rating', function (aErr, aScripts) {
+    if (aErr) { return aCallback(karma); }
 
-    karma = Math.floor(getRating(scripts) / 10);
-    if (karma > maxKarma) { karma = maxKarma; }
+    karma = Math.floor(getRating(aScripts) / 10);
+    if (karma > aMaxKarma) { karma = aMaxKarma; }
 
-    callback(karma);
+    aCallback(karma);
   });
 };
diff --git a/libs/flag.js b/libs/flag.js
index 7b9f938f2..2fa758a0f 100644
--- a/libs/flag.js
+++ b/libs/flag.js
@@ -9,134 +9,134 @@ var maxKarma = 10;
 // Determine whether content can be flagged by a user.
 // This is heavily commented so that my logic and
 // reasoning is documented for myself and others.
-function flaggable(model, content, user, callback) {
+function flaggable(aModel, aContent, aUser, aCallback) {
   // Not logged in.
-  if (!user) { return callback(false); }
+  if (!aUser) { return aCallback(false); }
 
 
   // You can't flag yourself
   // Only someone less than an admin can be flagged
   // It is not the responsibility of the community
   // to police the site administration
-  if (model.modelName === 'User') {
-    return getFlag(model, content, user, function (flag) {
-      callback(content._id != user._id && content.role > 2, content, flag);
+  if (aModel.modelName === 'User') {
+    return getFlag(aModel, aContent, aUser, function (aFlag) {
+      aCallback(aContent._id != aUser._id && aContent.role > 2, aContent, aFlag);
     });
   }
 
-  getAuthor(content, function (author) {
+  getAuthor(aContent, function (aAuthor) {
     // Content without an author shouldn't exist
-    if (!author) { return callback(false); }
+    if (!aAuthor) { return aCallback(false); }
 
     // You can't flag your own content
-    if (author._id == user._id) { return callback(false); }
+    if (aAuthor._id == aUser._id) { return aCallback(false); }
 
     // Content belonging to an admin or above cannot be flagged
-    if (author.role < 3) { return callback(author.role > 2, author); }
+    if (aAuthor.role < 3) { return aCallback(aAuthor.role > 2, aAuthor); }
 
     // You can't flag something twice
-    getFlag(model, content, user, function (flag) {
-      return callback(!flag, author, flag);
+    getFlag(aModel, aContent, aUser, function (aFlag) {
+      return aCallback(!aFlag, aAuthor, aFlag);
     });
   });
 }
 exports.flaggable = flaggable;
 
-function getFlag(model, content, user, callback) {
+function getFlag(aModel, aContent, aUser, aCallback) {
   Flag.findOne({
-    'model': model.modelName,
-    '_contentId': content._id,
-    '_userId': user._id
-  }, function (err, flag) {
-    callback(err || !flag ? null : flag);
+    'model': aModel.modelName,
+    '_contentId': aContent._id,
+    '_userId': aUser._id
+  }, function (aErr, aFlag) {
+    aCallback(aErr || !aFlag ? null : aFlag);
   });
 }
 
-function getAuthor(content, callback) {
-  User.findOne({ _id: content._authorId }, function (err, author) {
+function getAuthor(aContent, aCallback) {
+  User.findOne({ _id: aContent._authorId }, function (aErr, aAuthor) {
     // Content without an author shouldn't exist
-    if (err || !author) { return callback(null); }
+    if (aErr || !aAuthor) { return aCallback(null); }
 
-    callback(author);
+    aCallback(aAuthor);
   });
 }
 exports.getAuthor = getAuthor;
 
-function getThreshold(model, content, author, callback) {
+function getThreshold(aModel, aContent, aAuthor, aCallback) {
   // Admins can't be flagged so they have no threshold
-  if (author.role < 3) { return callback(null); }
+  if (aAuthor.role < 3) { return aCallback(null); }
 
   // Hardcode the threshold at 1.
   // modelQuery.applyModelListQueryFlaggedFilter supports this hardcoded number.
-  // return callback(1);
+  // return aCallback(1);
 
   // Moderators have a doubled threshold
-  var threshold = thresholds[model.modelName] * (author.role < 4 ? 2 : 1);
+  var threshold = thresholds[aModel.modelName] * (aAuthor.role < 4 ? 2 : 1);
 
   // Calculate karma and add it to the threshold
-  getKarma(author, maxKarma, function (karma) {
-    return callback(threshold + karma);
+  getKarma(aAuthor, maxKarma, function (aKarma) {
+    return aCallback(threshold + aKarma);
   });
 }
 exports.getThreshold = getThreshold;
 
-function saveContent(model, content, author, flags, callback) {
-  if (!content.flags) { content.flags = 0; }
-  content.flags += flags;
+function saveContent(aModel, aContent, aAuthor, flags, aCallback) { // TODO: Ambiguous
+  if (!aContent.flags) { aContent.flags = 0; }
+  aContent.flags += flags;
 
-  if (content.flags >= thresholds[model.modelName] * (author.role < 4 ? 2 : 1)) {
-    return getThreshold(model, content, author, function (threshold) {
-      content.flagged = content.flags >= threshold;
-      content.save(function (err, content) { callback(content.flagged); });
+  if (aContent.flags >= thresholds[aModel.modelName] * (aAuthor.role < 4 ? 2 : 1)) {
+    return getThreshold(aModel, aContent, aAuthor, function (aThreshold) {
+      aContent.flagged = aContent.flags >= aThreshold;
+      aContent.save(function (aErr, aContent) { aCallback(aContent.flagged); });
     });
   }
 
-  content.save(function (err, content) { callback(content.flagged); });
+  aContent.save(function (aErr, aContent) { aCallback(aContent.flagged); });
 }
 exports.saveContent = saveContent;
 
-function flag(model, content, user, author, callback) {
+function flag(aModel, aContent, aUser, aAuthor, aCallback) {
   var flag = new Flag({
-    'model': model.modelName,
-    '_contentId': content._id,
-    '_userId': user._id
+    'model': aModel.modelName,
+    '_contentId': aContent._id,
+    '_userId': aUser._id
   });
 
-  flag.save(function (err, flag) {
-    if (!content.flags) { content.flags = 0; }
-    if (!content.flagged) { content.flagged = false; }
+  flag.save(function (aErr, aFlag) {
+    if (!aContent.flags) { aContent.flags = 0; }
+    if (!aContent.flagged) { aContent.flagged = false; }
 
-    saveContent(model, content, author, user.role < 4 ? 2 : 1, callback)
+    saveContent(aModel, aContent, aAuthor, aUser.role < 4 ? 2 : 1, aCallback)
   });
 }
 
-exports.flag = function (model, content, user, callback) {
-  flaggable(model, content, user, function (canFlag, author) {
-    if (!canFlag) { return callback(false); }
+exports.flag = function (aModel, aContent, aUser, aCallback) {
+  flaggable(aModel, aContent, aUser, function (aCanFlag, aAuthor) {
+    if (!aCanFlag) { return aCallback(false); }
 
-    flag(model, content, user, author, callback);
+    flag(aModel, aContent, aUser, aAuthor, aCallback);
   });
 };
 
-exports.unflag = function (model, content, user, callback) {
-  if (!user) { return callback(null); }
+exports.unflag = function (aModel, aContent, aUser, aCallback) {
+  if (!aUser) { return aCallback(null); }
 
-  getFlag(model, content, user, function (flag) {
-    if (!flag) { return callback(null); }
+  getFlag(aModel, aContent, aUser, function (aFlag) {
+    if (!aFlag) { return aCallback(null); }
 
-    if (!content.flags) { content.flags = 0; }
-    if (!content.flagged) { content.flagged = false; }
+    if (!aContent.flags) { aContent.flags = 0; }
+    if (!aContent.flagged) { aContent.flagged = false; }
 
-    function removeFlag(author) {
-      flag.remove(function (err) {
-        saveContent(model, content, author, user.role < 4 ? -2 : -1, callback);
+    function removeFlag(aAuthor) {
+      aFlag.remove(function (aErr) {
+        saveContent(aModel, aContent, aAuthor, aUser.role < 4 ? -2 : -1, aCallback);
       });
     }
 
-    if (model.modelName === 'User') {
-      removeFlag(content);
+    if (aModel.modelName === 'User') {
+      removeFlag(aContent);
     } else {
-      getAuthor(content, removeFlag);
+      getAuthor(aContent, removeFlag);
     }
   });
 };
diff --git a/libs/githubClient.js b/libs/githubClient.js
index e2084d0c8..87e75a7a4 100644
--- a/libs/githubClient.js
+++ b/libs/githubClient.js
@@ -14,15 +14,15 @@ module.exports = github;
 
 // Authenticate Client
 var Strategy = require('../models/strategy').Strategy;
-Strategy.findOne({ name: 'github' }, function (err, strat) {
-  if (err)
-    console.error(err);
+Strategy.findOne({ name: 'github' }, function (aErr, aStrat) {
+  if (aErr)
+    console.error(aErr);
 
-  if (strat) {
+  if (aStrat) {
     github.authenticate({
       type: 'oauth',
-      key: strat.id,
-      secret: strat.key,
+      key: aStrat.id,
+      secret: aStrat.key,
     });
     console.log('GitHub client authenticated');
   } else {
@@ -34,63 +34,63 @@ Strategy.findOne({ name: 'github' }, function (err, strat) {
 // Util functions for the client.
 github.usercontent = github.usercontent || {};
 
-var githubGitDataGetBlobAsUtf8 = function (msg, callback) {
+var githubGitDataGetBlobAsUtf8 = function (aMsg, aCallback) {
   async.waterfall([
-    function (callback) {
-      github.gitdata.getBlob(msg, callback);
+    function (aCallback) {
+      github.gitdata.getBlob(aMsg, aCallback);
     },
-    function (blob, callback) {
-      var content = blob.content;
-      if (blob.encoding == 'base64') {
+    function (aBlob, aCallback) {
+      var content = aBlob.content;
+      if (aBlob.encoding == 'base64') {
         var buf = new Buffer(content, 'base64');
         content = buf.toString('utf8');
       }
-      callback(null, content);
+      aCallback(null, content);
     },
-  ], callback);
+  ], aCallback);
 };
 github.gitdata.getBlobAsUtf8 = githubGitDataGetBlobAsUtf8;
 
-var githubUserContentBuildUrl = function (user, repo, path) {
-  return util.format('https://raw.githubusercontent.com/%s/%s/HEAD/%s', user, repo, path);
+var githubUserContentBuildUrl = function (aUser, aRepo, aPath) {
+  return util.format('https://raw.githubusercontent.com/%s/%s/HEAD/%s', aUser, aRepo, aPath);
 };
 github.usercontent.buildUrl = githubUserContentBuildUrl;
 
-var githubUserContentGetBlobAsUtf8 = function (msg, callback) {
+var githubUserContentGetBlobAsUtf8 = function (aMsg, aCallback) {
   async.waterfall([
-    function (callback) {
-      var url = githubUserContentBuildUrl(msg.user, msg.repo, msg.path);
-      request.get(url, callback);
+    function (aCallback) {
+      var url = githubUserContentBuildUrl(aMsg.user, aMsg.repo, aMsg.path);
+      request.get(url, aCallback);
     },
-    function (response, body, callback) {
-      if (response.statusCode != 200)
-        return callback(util.format('Status Code %s', response.statusCode));
+    function (aResponse, aBody, aCallback) {
+      if (aResponse.statusCode != 200)
+        return aCallback(util.format('Status Code %s', aResponse.statusCode));
 
-      callback(null, body);
+      aCallback(null, aBody);
     },
-  ], callback);
+  ], aCallback);
 };
 
 github.usercontent.getBlobAsUtf8 = githubUserContentGetBlobAsUtf8;
 
-var githubGitDataIsJavascriptBlob = function (blob) {
-  return blob.path.match(/\.js$/);
+var githubGitDataIsJavascriptBlob = function (aBlob) {
+  return aBlob.path.match(/\.js$/);
 };
 github.gitdata.isJavascriptBlob = githubGitDataIsJavascriptBlob;
 
-var githubGitDataGetJavascriptBlobs = function (msg, callback) {
+var githubGitDataGetJavascriptBlobs = function (aMsg, aCallback) {
   async.waterfall([
-    function (callback) {
-      msg.sha = 'HEAD';
-      msg.recursive = true;
-      github.gitdata.getTree(msg, callback);
+    function (aCallback) {
+      aMsg.sha = 'HEAD';
+      aMsg.recursive = true;
+      github.gitdata.getTree(aMsg, aCallback);
     },
-    function (repoTree, callback) {
-      var entries = repoTree.tree;
+    function (aRepoTree, aCallback) {
+      var entries = aRepoTree.tree;
       var blobs = _.where(entries, { type: 'blob' });
       var javascriptBlobs = _.filter(blobs, githubGitDataIsJavascriptBlob);
-      callback(null, javascriptBlobs);
+      aCallback(null, javascriptBlobs);
     },
-  ], callback);
+  ], aCallback);
 };
 github.gitdata.getJavascriptBlobs = githubGitDataGetJavascriptBlobs;
diff --git a/libs/helpers.js b/libs/helpers.js
index 878fa5c54..9b177bbde 100644
--- a/libs/helpers.js
+++ b/libs/helpers.js
@@ -24,19 +24,19 @@ var day = hour * 24;
 var week = day * 7;
 
 // Get a formatted date that can be used everywhere a date is displayed
-exports.formatDate = function (date) {
-  var difference = new Date().getTime() - date.getTime();
+exports.formatDate = function (aDate) {
+  var difference = new Date().getTime() - aDate.getTime();
   var ret = '';
   var days = 0;
 
-  function pluralize(number, unit) {
-    return number + ' ' + unit + (number > 1 ? 's' : '') + ' ago';
+  function pluralize(aNumber, aUnit) {
+    return aNumber + ' ' + aUnit + (aNumber > 1 ? 's' : '') + ' ago';
   }
 
   if (difference > week) {
-    ret = date.getDate() + ' '
-      + months[date.getMonth()] + ' '
-      + date.getFullYear();
+    ret = aDate.getDate() + ' '
+      + months[aDate.getMonth()] + ' '
+      + aDate.getFullYear();
   } else if (difference > day) {
     days = Math.round(difference / day);
     if (days <= 1) {
@@ -56,61 +56,61 @@ exports.formatDate = function (date) {
 }
 
 // Create an object with no properties
-exports.nil = function (obj) {
+exports.nil = function (aObj) {
   var nilObj = Object.create(null);
 
-  if (!obj) return nilObj;
+  if (!aObj) return nilObj;
 
-  exports.forIn(obj, function (val, key) {
-    nilObj[key] = val;
+  exports.forIn(aObj, function (aVal, aKey) {
+    nilObj[aKey] = aVal;
   });
 
   return nilObj;
 };
 
 // Safely iterate on an object not create using nil()
-exports.forIn = function (obj, forProp) {
+exports.forIn = function (aObj, aForProp) {
   var key = null;
 
-  for (key in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key)) { continue; }
-    forProp(obj[key], key, obj);
+  for (key in aObj) {
+    if (!Object.prototype.hasOwnProperty.call(aObj, key)) { continue; }
+    aForProp(aObj[key], key, aObj);
   }
 };
 
 // Clean filenames but leave them readable
 // Based on Greasemonkey modules/remoteScript.js
-exports.cleanFilename = function (filename, defaultName) {
+exports.cleanFilename = function (aFilename, aDefaultName) {
   // Blacklist problem characters (slashes, colons, etc.).
-  var cleanName = (filename || '').replace(/[\\\/:*?\'\"<>|#;@=&]/g, '')
+  var cleanName = (aFilename || '').replace(/[\\\/:*?\'\"<>|#;@=&]/g, '')
 
   // Make whitespace readable.
   .replace(/(\s|%20)+/g, '_');
 
-  return cleanName || defaultName;
+  return cleanName || aDefaultName;
 };
 
-exports.limitRange = function (min, x, max) {
-  return Math.max(Math.min(x, max), min);
+exports.limitRange = function (aMin, aX, aMax) {
+  return Math.max(Math.min(aX, aMax), aMin);
 };
 
-exports.limitMin = function (min, x) {
-  return Math.max(x, min);
+exports.limitMin = function (aMin, aX) {
+  return Math.max(aX, aMin);
 };
 
-var setUrlQueryValue = function (baseUrl, queryVarKey, queryVarValue) {
+var setUrlQueryValue = function (aBaseUrl, aQueryVarKey, aQueryVarValue) {
   var parseQueryString = true;
-  var u = url.parse(baseUrl, parseQueryString);
-  u.query[queryVarKey] = queryVarValue;
+  var u = url.parse(aBaseUrl, parseQueryString);
+  u.query[aQueryVarKey] = aQueryVarValue;
   delete u.search; // http://stackoverflow.com/a/7517673/947742
   return url.format(u);
 };
 exports.setUrlQueryValue = setUrlQueryValue;
 
-exports.updateUrlQueryString = function (baseUrl, dict) {
-  var url = baseUrl;
-  _.each(dict, function (value, key) {
-    url = setUrlQueryValue(url, key, value);
+exports.updateUrlQueryString = function (aBaseUrl, aDict) {
+  var url = aBaseUrl;
+  _.each(aDict, function (aValue, aKey) {
+    url = setUrlQueryValue(url, aKey, aValue);
   });
   return url;
 };
diff --git a/libs/markdown.js b/libs/markdown.js
index 81d4ed44e..8801e45a7 100644
--- a/libs/markdown.js
+++ b/libs/markdown.js
@@ -16,51 +16,51 @@ var allWhitelistAttrs = htmlWhitelistPost.allowedAttributes.all;
 
 // Whitelist a bunch of attributes for all tags
 // Doing this until we have an upstream fix
-htmlWhitelistPost.allowedTags.forEach(function (tag) {
-  var otherAttrs = htmlWhitelistPost.allowedAttributes[tag];
+htmlWhitelistPost.allowedTags.forEach(function (aTag) {
+  var otherAttrs = htmlWhitelistPost.allowedAttributes[aTag];
 
-  htmlWhitelistPost.allowedAttributes[tag] = allWhitelistAttrs;
+  htmlWhitelistPost.allowedAttributes[aTag] = allWhitelistAttrs;
   if (otherAttrs) {
-    htmlWhitelistPost.allowedAttributes[tag] = htmlWhitelistPost
-      .allowedAttributes[tag].concat(otherAttrs);
+    htmlWhitelistPost.allowedAttributes[aTag] = htmlWhitelistPost
+      .allowedAttributes[aTag].concat(otherAttrs);
   }
 });
 delete htmlWhitelistPost.allowedAttributes.all;
 
-function sanitize(html) {
-  return sanitizeHtml(html, htmlWhitelistPost);
+function sanitize(aHtml) {
+  return sanitizeHtml(aHtml, htmlWhitelistPost);
 }
 
 // Sanitize the output from the block level renderers
-blockRenderers.forEach(function (type) {
-  renderer[type] = function () {
-    return sanitize(marked.Renderer.prototype[type].apply(renderer, arguments));
+blockRenderers.forEach(function (aType) {
+  renderer[aType] = function () {
+    return sanitize(marked.Renderer.prototype[aType].apply(renderer, arguments));
   };
 });
 
 // Automatically generate an anchor for each header
-renderer.heading = function (text, level) {
-  var escapedText = text.toLowerCase().replace(/<\/?[^>]+?>/g, '')
+renderer.heading = function (aText, aLevel) {
+  var escapedText = aText.toLowerCase().replace(/<\/?[^>]+?>/g, '')
     .replace(/[^\w]+/g, '-');
 
   var name = escapedText;
-  var html = '<h' + level + '>';
+  var html = '<h' + aLevel + '>';
   html += '<a name="' + name + '"></a>'
-  html += sanitize(text);
+  html += sanitize(aText);
   html += '<a href="#' + name + '" class="anchor">';
   html += '<i class="fa fa-link"></i>';
   html += '</a>';
-  html += '</h' + level + '>';
+  html += '</h' + aLevel + '>';
   return html;
 };
 
 // Set the options to use for rendering markdown
 marked.setOptions({
-  highlight: function (code, lang) {
-    if (lang && hljs.getLanguage(lang)) {
-      return hljs.highlight(lang, code).value;
+  highlight: function (aCode, aLang) {
+    if (aLang && hljs.getLanguage(aLang)) {
+      return hljs.highlight(aLang, aCode).value;
     } else {
-      return hljs.highlightAuto(code).value;
+      return hljs.highlightAuto(aCode).value;
     }
   },
   renderer: renderer,
@@ -73,6 +73,6 @@ marked.setOptions({
   smartypants: false
 });
 
-exports.renderMd = function (text) {
-  return marked(text);
+exports.renderMd = function (aText) {
+  return marked(aText);
 };
diff --git a/libs/modelParser.js b/libs/modelParser.js
index 71e0ea6a4..a85951e5d 100644
--- a/libs/modelParser.js
+++ b/libs/modelParser.js
@@ -20,14 +20,14 @@ var parseModelFnMap = {};
  * Misc: Dates
  */
 
-var momentLangFromNow = function(date) {
-  return '[' + date.fromNow() + ']';
+var momentLangFromNow = function(aDate) {
+  return '[' + aDate.fromNow() + ']';
 };
-var momentLangTinyDate = function(date) {
-  if(date.year() === moment().year()) {
-    return '[' + date.format("D MMM") + ']';
+var momentLangTinyDate = function(aDate) {
+  if(aDate.year() === moment().year()) {
+    return '[' + aDate.format("D MMM") + ']';
   } else {
-    return '[' + date.format("MMM 'YY") + ']';
+    return '[' + aDate.format("MMM 'YY") + ']';
   }
 };
 moment.lang('en-tiny', {
@@ -42,7 +42,7 @@ moment.lang('en-tiny', {
   relativeTime : {
     future : "in %s",
     past : "%s ago",
-    s : function (number, withoutSuffix, key, isFuture) { return number + "s"; },
+    s : function (aNumber, aWithoutSuffix, aKey, aIsFuture) { return aNumber + "s"; },
     m : "1m",
     mm : "%dm",
     h : "1h",
@@ -56,10 +56,10 @@ moment.lang('en-tiny', {
   }
 });
 
-var parseDateProperty = function (obj, key) {
-  var date = obj[key];
-  obj[key + 'ISOFormat'] = date.toISOString();
-  obj[key + 'Humanized'] = moment(date).lang('en-tiny').calendar();
+var parseDateProperty = function (aObj, aKey) {
+  var date = aObj[aKey];
+  aObj[aKey + 'ISOFormat'] = date.toISOString();
+  aObj[aKey + 'Humanized'] = moment(date).lang('en-tiny').calendar();
 };
 
 /**
@@ -71,39 +71,39 @@ var parseDateProperty = function (obj, key) {
  */
 
 // Urls
-var getScriptPageUrl = function (script) {
-  var isLib = script.isLib || false;
-  var scriptPath = script.installName
+var getScriptPageUrl = function (aScript) {
+  var isLib = aScript.isLib || false;
+  var scriptPath = aScript.installName
     .replace(isLib ? /\.js$/ : /\.user\.js$/, '');
   return (isLib ? '/libs/' : '/scripts/') + encodeURI(scriptPath);
 };
 
-var getScriptViewSourcePageUrl = function (script) {
-  return getScriptPageUrl(script) + '/source';
+var getScriptViewSourcePageUrl = function (aScript) {
+  return getScriptPageUrl(aScript) + '/source';
 };
 
-var getScriptEditAboutPageUrl = function (script) {
-  var isLib = script.isLib || false;
-  var scriptPath = script.installName
+var getScriptEditAboutPageUrl = function (aScript) {
+  var isLib = aScript.isLib || false;
+  var scriptPath = aScript.installName
     .replace(isLib ? /\.js$/ : /\.user\.js$/, '');
   var editUrl = scriptPath.split('/');
   editUrl.shift();
   return (isLib ? '/lib/' : '/script/') + editUrl.join('/') + '/edit';
 };
 
-var getScriptEditSourcePageUrl = function (script) {
-  return getScriptViewSourcePageUrl(script);
+var getScriptEditSourcePageUrl = function (aScript) {
+  return getScriptViewSourcePageUrl(aScript);
 };
 
-var getScriptInstallPageUrl = function (script) {
-  var isLib = script.isLib || false;
-  return (isLib ? '/src/libs/' : '/install/') + script.installName;
+var getScriptInstallPageUrl = function (aScript) {
+  var isLib = aScript.isLib || false;
+  return (isLib ? '/src/libs/' : '/install/') + aScript.installName;
 };
 
 //
-var parseScript = function (scriptData) {
-  if (!scriptData) return;
-  var script = scriptData.toObject ? scriptData.toObject() : scriptData;
+var parseScript = function (aScriptData) {
+  if (!aScriptData) return;
+  var script = aScriptData.toObject ? aScriptData.toObject() : aScriptData;
 
   // Temporaries
   var htmlStub = null;
@@ -199,9 +199,9 @@ var parseScript = function (scriptData) {
 parseModelFnMap.Script = parseScript;
 exports.parseScript = parseScript;
 
-exports.renderScript = function (script) {
-  if (!script) return;
-  script.aboutRendered = renderMd(script.about);
+exports.renderScript = function (aScript) {
+  if (!aScript) return;
+  aScript.aboutRendered = renderMd(aScript.about);
 };
 
 /**
@@ -209,10 +209,12 @@ exports.renderScript = function (script) {
  */
 
 //
-var parseUser = function (userData) {
-  if (!userData) return;
-  // var user = userData.toObject ? userData.toObject() : userData;
-  var user = userData;
+var parseUser = function (aUserData) {
+  if (!aUserData) return;
+  // var user = aUserData.toObject ? aUserData.toObject() : aUserData;
+
+  // Intermediates
+  var user = aUserData;
 
   // Role
   user.isMod = user.role < 4;
@@ -254,10 +256,12 @@ exports.parseUser = parseUser;
  */
 
 //
-var parseGroup = function (groupData) {
-  if (!groupData) return;
-  // var group = groupData.toObject ? groupData.toObject() : groupData;
-  var group = groupData;
+var parseGroup = function (aGroupData) {
+  if (!aGroupData) return;
+  // var group = aGroupData.toObject ? aGroupData.toObject() : aGroupData;
+
+  // Intermediates
+  var group = aGroupData;
 
   group.size = group._scriptIds.length;
   group.multiple = group._scriptIds.length > 1;
@@ -269,14 +273,14 @@ var parseGroup = function (groupData) {
   if (new Date().getTime() > (group.updated.getTime() + 1000 * 60 * 60 * 2)) {
     Script.find({
       _id: { $in: group._scriptIds }
-    }, function (err, scripts) {
-      if (!err && scripts.length > 1) {
-        group.rating = getRating(scripts);
+    }, function (aErr, aScripts) {
+      if (!aErr && aScripts.length > 1) {
+        group.rating = getRating(aScripts);
       }
 
       group.updated = new Date();
-      group.save(function (err, group) {
-        console.log(util.format('Group(%s) Rating Updated', group.name));
+      group.save(function (aErr, aGroup) {
+        console.log(util.format('Group(%s) Rating Updated', aGroup.name));
       });
     });
   }
@@ -291,10 +295,10 @@ exports.parseGroup = parseGroup;
  */
 
 //
-var parseDiscussion = function (discussionData) {
-  if (!discussionData) return;
-  var discussion = discussionData.toObject ? discussionData.toObject() : discussionData;
-  // var discussion = discussionData; // Can't override discussionData.category
+var parseDiscussion = function (aDiscussionData) {
+  if (!aDiscussionData) return;
+  var discussion = aDiscussionData.toObject ? aDiscussionData.toObject() : aDiscussionData;
+  // var discussion = aDiscussionData; // Can't override discussionData.category
 
   // Urls
   discussion.discussionPageUrl = discussion.path + (discussion.duplicateId ? '_' + discussion.duplicateId : '');
@@ -309,9 +313,9 @@ var parseDiscussion = function (discussionData) {
     recentCommentors.push(discussion.author);
   if (discussion.lastCommentor != discussion.author)
     recentCommentors.push(discussion.lastCommentor);
-  recentCommentors = _.map(recentCommentors, function (username) {
+  recentCommentors = _.map(recentCommentors, function (aUsername) {
     return {
-      name: username,
+      name: aUsername
     };
   });
   discussion.recentCommentors = recentCommentors;
@@ -326,9 +330,9 @@ var parseDiscussion = function (discussionData) {
 parseModelFnMap.Discussion = parseDiscussion;
 exports.parseDiscussion = parseDiscussion;
 
-var parseIssue = function (discussionData) {
-  if (!discussionData) return;
-  var discussion = discussionData.toObject ? discussionData.toObject() : discussionData;
+var parseIssue = function (aDiscussionData) {
+  if (!aDiscussionData) return;
+  var discussion = aDiscussionData.toObject ? aDiscussionData.toObject() : aDiscussionData;
 
   discussion.issue = true;
   discussion.open = (discussion.open === undefined || discussion.open === null) ? true : discussion.open;
@@ -346,9 +350,9 @@ exports.parseIssue = parseIssue;
  */
 
 //
-var parseComment = function (commentData) {
-  if (!commentData) return;
-  var comment = commentData.toObject ? commentData.toObject() : commentData;
+var parseComment = function (aCommentData) {
+  if (!aCommentData) return;
+  var comment = aCommentData.toObject ? aCommentData.toObject() : aCommentData;
 
   // Dates
   parseDateProperty(comment, 'created');
@@ -358,24 +362,24 @@ var parseComment = function (commentData) {
 parseModelFnMap.Comment = parseComment;
 exports.parseComment = parseComment;
 
-exports.renderComment = function (comment) {
-  if (!comment) return;
-  comment.contentRendered = renderMd(comment.content);
+exports.renderComment = function (aComment) {
+  if (!aComment) return;
+  aComment.contentRendered = renderMd(aComment.content);
 };
 
 /**
  * Category
  */
 
-var canUserPostTopicToCategory = function (user, category) {
+var canUserPostTopicToCategory = function (aUser, aCategory) {
   // Check if user is logged in.
-  if (_.isUndefined(user) || _.isNull(user))
+  if (_.isUndefined(aUser) || _.isNull(aUser))
     return false; // Not logged in.
 
   // Check if this category requires a minimum role to post topics.
-  console.log(category.roleReqToPostTopic, _.isNumber(category.roleReqToPostTopic), user.role, user.role <= category.roleReqToPostTopic)
-  if (_.isNumber(category.roleReqToPostTopic)) {
-    return user.role <= category.roleReqToPostTopic;
+  console.log(aCategory.roleReqToPostTopic, _.isNumber(aCategory.roleReqToPostTopic), aUser.role, aUser.role <= aCategory.roleReqToPostTopic)
+  if (_.isNumber(aCategory.roleReqToPostTopic)) {
+    return aUser.role <= aCategory.roleReqToPostTopic;
   } else {
     // No specified role required
     return true;
@@ -383,17 +387,17 @@ var canUserPostTopicToCategory = function (user, category) {
 };
 
 //
-var parseCategory = function (categoryData) {
-  if (!categoryData) return;
-  var category = categoryData.toObject ? categoryData.toObject() : categoryData;
+var parseCategory = function (aCategoryData) {
+  if (!aCategoryData) return;
+  var category = aCategoryData.toObject ? aCategoryData.toObject() : aCategoryData;
 
   // Urls
   category.categoryPageUrl = '/' + category.slug;
   category.categoryPostDiscussionPageUrl = '/post/' + category.slug;
 
   // Functions
-  category.canUserPostTopic = function (user) {
-    return canUserPostTopicToCategory(user, category);
+  category.canUserPostTopic = function (aUser) {
+    return canUserPostTopicToCategory(aUser, category);
   };
 
   return category;
@@ -405,28 +409,28 @@ exports.parseCategory = parseCategory;
  * Remove
  */
 
-var getRemovedItemDescription = function (remove) {
-  if (!remove.content)
+var getRemovedItemDescription = function (aRemove) {
+  if (!aRemove.content)
     return 'No content';
 
-  switch (remove.model) {
+  switch (aRemove.model) {
     case 'User':
-      return remove.content.name;
+      return aRemove.content.name;
     case 'Script':
-      return remove.content.fullName || remove.content.name;
+      return aRemove.content.fullName || aRemove.content.name;
     case 'Comment':
-      return util.format('by %s', remove.content.author);
+      return util.format('by %s', aRemove.content.author);
     case 'Discussion':
-      return remove.content.path;
+      return aRemove.content.path;
     default:
-      return remove.content._id;
+      return aRemove.content._id;
   }
 };
 
 //
-var parseRemovedItem = function (removedItemData) {
-  if (!removedItemData) return;
-  var removedItem = removedItemData;
+var parseRemovedItem = function (aRemovedItemData) {
+  if (!aRemovedItemData) return;
+  var removedItem = aRemovedItemData;
 
   // Dates
   parseDateProperty(removedItem, 'removed');
diff --git a/libs/modelQuery.js b/libs/modelQuery.js
index da2f99acf..6399a6af0 100644
--- a/libs/modelQuery.js
+++ b/libs/modelQuery.js
@@ -4,140 +4,140 @@ var _ = require('underscore');
 
 var getDefaultPagination = require('../libs/templateHelpers').getDefaultPagination;
 
-var findOrDefaultIfNull = function (query, key, value, defaultValue) {
+var findOrDefaultIfNull = function (aQuery, aKey, aValue, aDefaultValue) {
   var conditions = [];
   var condition = {};
-  condition[key] = value;
+  condition[aKey] = aValue;
   conditions.push(condition);
-  if (value == defaultValue) {
+  if (aValue == aDefaultValue) {
     condition = {};
-    condition[key] = null;
+    condition[aKey] = null;
     conditions.push(condition);
   }
-  query.and({ $or: conditions });
+  aQuery.and({ $or: conditions });
 };
 exports.findOrDefaultIfNull = findOrDefaultIfNull;
 
 var orderDirs = ['asc', 'desc'];
-var parseModelListSort = function (modelListQuery, orderBy, orderDir, defaultSortFn) {
-  if (orderBy) {
-    if (_.isUndefined(orderDir) || !_.contains(orderDirs, orderDir))
-      orderDir = 'asc';
+var parseModelListSort = function (aModelListQuery, aOrderBy, aOrderDir, aDefaultSortFn) {
+  if (aOrderBy) {
+    if (_.isUndefined(aOrderDir) || !_.contains(orderDirs, aOrderDir))
+      aOrderDir = 'asc';
 
-    if (_.has(modelListQuery.model.schema.paths, orderBy)) {
+    if (_.has(aModelListQuery.model.schema.paths, aOrderBy)) {
       var sortBy = {};
-      sortBy[orderBy] = orderDir;
-      modelListQuery.sort(sortBy);
+      sortBy[aOrderBy] = aOrderDir;
+      aModelListQuery.sort(sortBy);
       return;
     }
   }
-  defaultSortFn(modelListQuery);
+  aDefaultSortFn(aModelListQuery);
 };
 exports.parseModelListSort = parseModelListSort;
 
-var parseSearchConditions = function (q, prefixSearchFields, fullSearchFields) {
+var parseSearchConditions = function (aQ, aPrefixSearchFields, aFullSearchFields) { // NOTE: This code is duplicated elsewhere but this is primary
   var conditions = [];
   var query = null;
   var prefixStr = '';
   var fullStr = '';
   var prefixRegex = null;
   var fullRegex = null;
-  var terms = q.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1').split(/\s+/).map(function (e) { return e.trim(); });
+  var terms = aQ.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1').split(/\s+/).map(function (aE) { return aE.trim(); });
 
   // Match all the terms but in any order
-  terms.forEach(function (term) {
-    var isNonASCII = /^\W/.test(term);
+  terms.forEach(function (aTerm) {
+    var isNonASCII = /^\W/.test(aTerm);
     if (isNonASCII) {
-      prefixStr += '(?=.*?([ \n\r\t.,\'"\+!?-]+)' + term + ')';
+      prefixStr += '(?=.*?([ \n\r\t.,\'"\+!?-]+)' + aTerm + ')';
     } else {
-      prefixStr += '(?=.*?\\b' + term + ')';
+      prefixStr += '(?=.*?\\b' + aTerm + ')';
     }
-    fullStr += '(?=.*?' + term + ')';
+    fullStr += '(?=.*?' + aTerm + ')';
   });
   prefixRegex = new RegExp(prefixStr, 'i');
   fullRegex = new RegExp(fullStr, 'i');
 
   // One of the searchable fields must match the conditions
-  prefixSearchFields.forEach(function (prop) {
+  aPrefixSearchFields.forEach(function (aProp) {
     var condition = {};
-    condition[prop] = prefixRegex;
+    condition[aProp] = prefixRegex;
     conditions.push(condition);
   });
 
-  fullSearchFields.forEach(function (prop) {
+  aFullSearchFields.forEach(function (aProp) {
     var condition = {};
-    condition[prop] = fullRegex;
+    condition[aProp] = fullRegex;
     conditions.push(condition);
   });
   return conditions;
 };
 exports.parseSearchConditions = parseSearchConditions;
 
-var parseModelListSearchQuery = function (modelListQuery, query, searchOptions) {
-  var q = unescape(query);
-  modelListQuery.and({
-    $or: parseSearchConditions(q, searchOptions.partialWordMatchFields, searchOptions.fullWordMatchFields)
+var parseModelListSearchQuery = function (aModelListQuery, aQuery, aSearchOptions) {
+  var q = unescape(aQuery);
+  aModelListQuery.and({
+    $or: parseSearchConditions(q, aSearchOptions.partialWordMatchFields, aSearchOptions.fullWordMatchFields)
   });
 };
 
-var parseScriptSearchQuery = function (scriptListQuery, query) {
-  parseModelListSearchQuery(scriptListQuery, query, {
+var parseScriptSearchQuery = function (aScriptListQuery, aQuery) {
+  parseModelListSearchQuery(aScriptListQuery, aQuery, {
     partialWordMatchFields: ['name', 'author', 'about', 'meta.description'],
     fullWordMatchFields: ['meta.include', 'meta.match'],
   });
 };
 exports.parseScriptSearchQuery = parseScriptSearchQuery;
 
-var parseGroupSearchQuery = function (groupListQuery, query) {
-  parseModelListSearchQuery(groupListQuery, query, {
+var parseGroupSearchQuery = function (aGroupListQuery, aQuery) {
+  parseModelListSearchQuery(aGroupListQuery, query, {
     partialWordMatchFields: ['name'],
     fullWordMatchFields: [],
   });
 };
 exports.parseGroupSearchQuery = parseGroupSearchQuery;
 
-var parseDiscussionSearchQuery = function (discussionListQuery, query) {
-  parseModelListSearchQuery(discussionListQuery, query, {
+var parseDiscussionSearchQuery = function (aDiscussionListQuery, aQuery) {
+  parseModelListSearchQuery(aDiscussionListQuery, query, {
     partialWordMatchFields: ['topic'],
     fullWordMatchFields: ['author'],
   });
 };
 exports.parseDiscussionSearchQuery = parseDiscussionSearchQuery;
 
-var parseCommentSearchQuery = function (commentListQuery, query) {
-  parseModelListSearchQuery(commentListQuery, query, {
+var parseCommentSearchQuery = function (aCommentListQuery, aQuery) {
+  parseModelListSearchQuery(aCommentListQuery, aQuery, {
     partialWordMatchFields: ['content'],
     fullWordMatchFields: ['author'],
   });
 };
 exports.parseCommentSearchQuery = parseCommentSearchQuery;
 
-var parseUserSearchQuery = function (userListQuery, query) {
-  parseModelListSearchQuery(userListQuery, query, {
+var parseUserSearchQuery = function (aUserListQuery, aQuery) {
+  parseModelListSearchQuery(aUserListQuery, aQuery, {
     partialWordMatchFields: ['name'],
     fullWordMatchFields: [],
   });
 };
 exports.parseCommentSearchQuery = parseCommentSearchQuery;
 
-var parseRemovedItemSearchQuery = function (removedItemListQuery, query) {
-  parseModelListSearchQuery(removedItemListQuery, query, {
+var parseRemovedItemSearchQuery = function (aRemovedItemListQuery, aQuery) {
+  parseModelListSearchQuery(aRemovedItemListQuery, aQuery, {
     partialWordMatchFields: ['content.*'],
     fullWordMatchFields: ['model'],
   });
 };
 exports.parseCommentSearchQuery = parseCommentSearchQuery;
 
-var applyModelListQueryFlaggedFilter = function (modelListQuery, options, flaggedQuery) {
+var applyModelListQueryFlaggedFilter = function (aModelListQuery, aOptions, aFlaggedQuery) {
   // Only list flagged items if authedUser >= moderator or if authedUser owns the item.
-  if (options.isYou || options.isMod) {
+  if (aOptions.isYou || aOptions.isMod) {
     // Mod
-    if (flaggedQuery) {
-      if (flaggedQuery == 'true') {
-        options.isFlagged = true;
-        modelListQuery.and({ flags: { $gt: 0 } });
-      } else if (flaggedQuery == false) {
-        // modelListQuery.and({$or: [
+    if (aFlaggedQuery) {
+      if (aFlaggedQuery == 'true') {
+        aOptions.isFlagged = true;
+        aModelListQuery.and({ flags: { $gt: 0 } });
+      } else if (aFlaggedQuery == false) {
+        // aModelListQuery.and({$or: [
         //   {flags: {$exists: false}},
         //   {flags: {$lte: 0} },
         // ]});
@@ -146,41 +146,41 @@ var applyModelListQueryFlaggedFilter = function (modelListQuery, options, flagge
   } else {
     // Hide
     // Script.flagged is undefined by default.
-    modelListQuery.and({ flagged: { $ne: true } });
+    aModelListQuery.and({ flagged: { $ne: true } });
   }
 };
 exports.applyModelListQueryFlaggedFilter = applyModelListQueryFlaggedFilter;
 
-var applyModelListQueryDefaults = function (modelListQuery, options, req, defaultOptions) {
+var applyModelListQueryDefaults = function (aModelListQuery, aOptions, aReq, aDefaultOptions) {
 
   // Search
-  if (req.query.q) {
-    options.searchBarValue = req.query.q;
+  if (aReq.query.q) {
+    aOptions.searchBarValue = aReq.query.q;
 
-    if (defaultOptions.parseSearchQueryFn)
-      defaultOptions.parseSearchQueryFn(modelListQuery, req.query.q);
+    if (aDefaultOptions.parseSearchQueryFn)
+      aDefaultOptions.parseSearchQueryFn(aModelListQuery, aReq.query.q);
   }
-  options.searchBarFormAction = defaultOptions.searchBarFormAction || '';
-  options.searchBarPlaceholder = defaultOptions.searchBarPlaceholder || 'Search';
-  options.searchBarFormHiddenVariables = defaultOptions.searchBarFormHiddenVariables || [];
+  aOptions.searchBarFormAction = aDefaultOptions.searchBarFormAction || '';
+  aOptions.searchBarPlaceholder = aDefaultOptions.searchBarPlaceholder || 'Search';
+  aOptions.searchBarFormHiddenVariables = aDefaultOptions.searchBarFormHiddenVariables || [];
 
   // flagged
-  if (defaultOptions.filterFlaggedItems)
-    applyModelListQueryFlaggedFilter(modelListQuery, options, req.query.flagged);
+  if (aDefaultOptions.filterFlaggedItems)
+    applyModelListQueryFlaggedFilter(aModelListQuery, aOptions, aReq.query.flagged);
 
   // Sort
-  parseModelListSort(modelListQuery, req.query.orderBy, req.query.orderDir, function () {
-    modelListQuery.sort(defaultOptions.defaultSort);
+  parseModelListSort(aModelListQuery, aReq.query.orderBy, aReq.query.orderDir, function () {
+    aModelListQuery.sort(aDefaultOptions.defaultSort);
   });
 
   // Pagination
-  var pagination = getDefaultPagination(req);
-  pagination.applyToQuery(modelListQuery);
-  options.pagination = pagination;
+  var pagination = getDefaultPagination(aReq);
+  pagination.applyToQuery(aModelListQuery);
+  aOptions.pagination = pagination;
 };
 
-exports.applyCommentListQueryDefaults = function (commentListQuery, options, req) {
-  applyModelListQueryDefaults(commentListQuery, options, req, {
+exports.applyCommentListQueryDefaults = function (aCommentListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aCommentListQuery, aOptions, aReq, {
     defaultSort: 'created',
     parseSearchQueryFn: parseCommentSearchQuery,
     searchBarPlaceholder: 'Search Comments',
@@ -188,15 +188,15 @@ exports.applyCommentListQueryDefaults = function (commentListQuery, options, req
   });
 
   // Populate
-  commentListQuery.populate({
+  aCommentListQuery.populate({
     path: '_authorId',
     model: 'User',
     select: 'name role'
   });
 };
 
-exports.applyDiscussionListQueryDefaults = function (discussionListQuery, options, req) {
-  applyModelListQueryDefaults(discussionListQuery, options, req, {
+exports.applyDiscussionListQueryDefaults = function (aDiscussionListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aDiscussionListQuery, aOptions, aReq, {
     defaultSort: '-updated -rating',
     parseSearchQueryFn: parseDiscussionSearchQuery,
     searchBarPlaceholder: 'Search Topics',
@@ -204,8 +204,8 @@ exports.applyDiscussionListQueryDefaults = function (discussionListQuery, option
   });
 };
 
-exports.applyGroupListQueryDefaults = function (groupListQuery, options, req) {
-  applyModelListQueryDefaults(groupListQuery, options, req, {
+exports.applyGroupListQueryDefaults = function (aGroupListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aGroupListQuery, aOptions, aReq, {
     defaultSort: '-rating name',
     parseSearchQueryFn: parseGroupSearchQuery,
     searchBarPlaceholder: 'Search Groups',
@@ -221,8 +221,8 @@ var scriptListQueryDefaults = {
   filterFlaggedItems: true
 };
 exports.scriptListQueryDefaults = scriptListQueryDefaults;
-exports.applyScriptListQueryDefaults = function (scriptListQuery, options, req) {
-  applyModelListQueryDefaults(scriptListQuery, options, req, scriptListQueryDefaults);
+exports.applyScriptListQueryDefaults = function (aScriptListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aScriptListQuery, aOptions, aReq, scriptListQueryDefaults);
 };
 
 var libraryListQueryDefaults = {
@@ -236,12 +236,12 @@ var libraryListQueryDefaults = {
   filterFlaggedItems: true
 };
 exports.libraryListQueryDefaults = libraryListQueryDefaults;
-exports.applyLibraryListQueryDefaults = function (libraryListQuery, options, req) {
-  applyModelListQueryDefaults(libraryListQuery, options, req, libraryListQueryDefaults);
+exports.applyLibraryListQueryDefaults = function (aLibraryListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aLibraryListQuery, aOptions, aReq, libraryListQueryDefaults);
 };
 
-exports.applyUserListQueryDefaults = function (userListQuery, options, req) {
-  applyModelListQueryDefaults(userListQuery, options, req, {
+exports.applyUserListQueryDefaults = function (aUserListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aUserListQuery, aOptions, aReq, {
     defaultSort: 'name',
     parseSearchQueryFn: parseUserSearchQuery,
     searchBarPlaceholder: 'Search Users',
@@ -249,8 +249,8 @@ exports.applyUserListQueryDefaults = function (userListQuery, options, req) {
   });
 };
 
-exports.applyRemovedItemListQueryDefaults = function (removedItemListQuery, options, req) {
-  applyModelListQueryDefaults(removedItemListQuery, options, req, {
+exports.applyRemovedItemListQueryDefaults = function (aRemovedItemListQuery, aOptions, aReq) {
+  applyModelListQueryDefaults(aRemovedItemListQuery, aOptions, aReq, {
     defaultSort: '-removed',
     parseSearchQueryFn: parseRemovedItemSearchQuery,
     searchBarPlaceholder: 'Search Removed Items',
diff --git a/libs/modelsList.js b/libs/modelsList.js
index 47a8d655c..e862a8f61 100644
--- a/libs/modelsList.js
+++ b/libs/modelsList.js
@@ -14,25 +14,25 @@ var listSize = 10;
 // /scriptlist/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of scripts and build the options object
 // for the corresponding Mustache partial template
-exports.listScripts = function (query, params, baseUrl, callback) {
+exports.listScripts = function (aQuery, aParams, aBaseUrl, aCallback) {
 
   // Don't list flagged scripts by default
-  if (query.flagged === null) {
-    delete query.flagged;
-  } else if (query.flagged !== true) {
-    query.flagged = { $ne: true };
+  if (aQuery.flagged === null) {
+    delete aQuery.flagged;
+  } else if (aQuery.flagged !== true) {
+    aQuery.flagged = { $ne: true };
   }
 
   // List both libraries and scripts if isLib is null
   // Only list scripts and omit libraries by default
-  if (query.isLib === null) {
-    delete query.isLib;
-  } else if (!query.isLib) {
-    query.isLib = { $ne: true };
+  if (aQuery.isLib === null) {
+    delete aQuery.isLib;
+  } else if (!aQuery.isLib) {
+    aQuery.isLib = { $ne: true };
   }
 
-  listModels(Script, query, params, ['rating', 'installs', 'updated'],
-    function (scripts, scriptsList) {
+  listModels(Script, aQuery, aParams, ['rating', 'installs', 'updated'],
+    function (aScripts, aScriptsList) {
       /*var headings = {
         'name': { label: 'Name', width: 50 },
         'author': { label: 'Author', width: 15 },
@@ -41,36 +41,36 @@ exports.listScripts = function (query, params, baseUrl, callback) {
       };*/
       var heading = null;
       var name = null;
-      scriptsList.scripts = [];
-      scriptsList.headings = [];
-      scriptsList.hasAuthor = params[4] ?
-        params[4].indexOf('author') === -1 : true;
-
-      scripts.forEach(function (script) {
-        var isLib = script.isLib || false;
-        var scriptPath = script.installName
+      aScriptsList.scripts = [];
+      aScriptsList.headings = [];
+      aScriptsList.hasAuthor = aParams[4] ?
+        aParams[4].indexOf('author') === -1 : true;
+
+      aScripts.forEach(function (aScript) {
+        var isLib = aScript.isLib || false;
+        var scriptPath = aScript.installName
           .replace(isLib ? /\.js$/ : /\.user\.js$/, '');
         var editUrl = scriptPath.split('/');
 
         editUrl.shift();
 
-        scriptsList.scripts.push({
-          name: script.name,
-          author: script.author,
-          description: script.meta.description || '',
+        aScriptsList.scripts.push({
+          name: aScript.name,
+          author: aScript.author,
+          description: aScript.meta.description || '',
           url: (isLib ? '/libs/' : '/scripts/') + scriptPath,
-          install: (isLib ? '/libs/src/' : '/install/') + script.installName,
+          install: (isLib ? '/libs/src/' : '/install/') + aScript.installName,
           editUrl: (isLib ? '/lib/' : '/script/') + editUrl.join('/') + '/edit',
-          rating: script.rating,
-          installs: script.installs,
-          version: script.meta.version || '',
-          isLib: script.isLib,
-          updated: formatDate(script.updated)
+          rating: aScript.rating,
+          installs: aScript.installs,
+          version: aScript.meta.version || '',
+          isLib: aScript.isLib,
+          updated: formatDate(aScript.updated)
         });
       });
 
       /*for (name in headings) {
-        if (!scriptsList.hasAuthor && name === 'author') { continue; }
+        if (!aScriptsList.hasAuthor && name === 'author') { continue; }
         heading = headings[name];
 
         if (orderBy === name) {
@@ -81,45 +81,45 @@ exports.listScripts = function (query, params, baseUrl, callback) {
         }
 
         heading.name = name;
-        scriptsList.headings.push(heading);
+        aScriptsList.headings.push(heading);
       }*/
 
-      scriptsList.baseUrl = baseUrl + (query.isLib === true ?
+      aScriptsList.baseUrl = aBaseUrl + (aQuery.isLib === true ?
         '/liblist' : '/scriptlist');
-      callback(scriptsList);
+      aCallback(aScriptsList);
     });
 };
 
 // /userlist/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of users and build the options object
 // for the corresponding Mustache partial template
-exports.listUsers = function (query, params, baseUrl, callback) {
-  listModels(User, query, params, ['name'],
-    function (users, usersList) {
-      usersList.users = [];
-
-      users.forEach(function (user) {
-        usersList.users.push({
-          name: user.name,
-          url: '/users/' + user.name,
+exports.listUsers = function (aQuery, aParams, aBaseUrl, aCallback) {
+  listModels(User, aQuery, aParams, ['name'],
+    function (aUsers, aUsersList) {
+      aUsersList.users = [];
+
+      aUsers.forEach(function (aUser) {
+        aUsersList.users.push({
+          name: aUser.name,
+          url: '/users/' + aUser.name,
         });
       });
 
-      usersList.baseUrl = baseUrl + '/userlist';
-      callback(usersList);
+      aUsersList.baseUrl = aBaseUrl + '/userlist';
+      aCallback(aUsersList);
     });
 };
 
 // /list/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of removed content and build the options object
 // for the corresponding Mustache partial template
-exports.listRemoved = function (query, params, baseUrl, callback) {
-  listModels(Remove, query, params, ['removed'],
-    function (results, removedList) {
-      removedList.removed = [];
+exports.listRemoved = function (aQuery, aParams, aBaseUrl, aCallback) {
+  listModels(Remove, aQuery, aParams, ['removed'],
+    function (aResults, aRemovedList) {
+      aRemovedList.removed = [];
 
-      results.forEach(function (result) {
-        var content = result.content;
+      aResults.forEach(function (aResult) {
+        var content = aResult.content;
         var key = null;
         var contentArr = [];
         var val = null;
@@ -130,103 +130,103 @@ exports.listRemoved = function (query, params, baseUrl, callback) {
           contentArr.push({ 'key': key, 'value': val });
         }
 
-        removedList.removed.push({
-          remover: result.removerName,
-          removed: formatDate(result.removed),
-          reason: result.reason,
+        aRemovedList.removed.push({
+          remover: aResult.removerName,
+          removed: formatDate(aResult.removed),
+          reason: aResult.reason,
           content: contentArr
         });
       });
 
-      removedList.baseUrl = baseUrl + '/list';
-      callback(removedList);
+      aRemovedList.baseUrl = aBaseUrl + '/list';
+      aCallback(aRemovedList);
     });
 };
 
 // /groups/list/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of groups and build the options object
 // for the corresponding Mustache partial template
-exports.listGroups = function (query, params, baseUrl, callback) {
-  listModels(Group, query, params, ['rating'],
-    function (groups, groupsList) {
-      groupsList.groups = [];
-
-      groups.forEach(function (group) {
-        groupsList.groups.push({
-          name: group.name,
-          url: '/group/' + group.name.replace(/\s+/g, '_'),
-          size: group._scriptIds.length,
-          multiple: group._scriptIds.length > 1
+exports.listGroups = function (aQuery, aParams, aBaseUrl, aCallback) {
+  listModels(Group, aQuery, aParams, ['rating'],
+    function (aGroups, aGroupsList) {
+      aGroupsList.groups = [];
+
+      aGroups.forEach(function (aGroup) {
+        aGroupsList.groups.push({
+          name: aGroup.name,
+          url: '/group/' + aGroup.name.replace(/\s+/g, '_'),
+          size: aGroup._scriptIds.length,
+          multiple: aGroup._scriptIds.length > 1
         });
 
         // Wait two hours between group rating updates
         // This calculation runs in the background
-        if (new Date().getTime() > (group.updated.getTime() + 1000 * 60 * 60 * 2)) {
-          Script.find({ _id: { $in: group._scriptIds } },
-            function (err, scripts) {
-              if (!err && scripts.length > 1) {
-                group.rating = getRating(scripts);
+        if (new Date().getTime() > (aGroup.updated.getTime() + 1000 * 60 * 60 * 2)) {
+          Script.find({ _id: { $in: aGroup._scriptIds } },
+            function (aErr, aScripts) {
+              if (!aErr && aScripts.length > 1) {
+                aGroup.rating = getRating(aScripts);
               }
 
-              group.updated = new Date();
-              group.save(function () { });
+              aGroup.updated = new Date();
+              aGroup.save(function () { });
             });
         }
       });
 
-      groupsList.baseUrl = baseUrl + '/list';
-      callback(groupsList);
+      aGroupsList.baseUrl = aBaseUrl + '/list';
+      aCallback(aGroupsList);
     });
 };
 
 // /list/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of discussions and build the options object
 // for the corresponding Mustache partial template
-exports.listDiscussions = function (query, params, baseUrl, callback) {
-  listModels(Discussion, query, params, ['updated', 'rating'],
-    function (discussions, discussionsList) {
-      discussionsList.discussions = [];
-
-      discussions.forEach(function (discussion) {
-        discussionsList.discussions.push({
-          topic: discussion.topic,
-          comments: discussion.comments,
-          author: discussion.author,
-          created: discussion.created,
-          lastCommentor: discussion.author != discussion.lastCommentor ?
-            discussion.lastCommentor : null,
-          updated: formatDate(discussion.updated),
-          rating: discussion.rating,
-          url: discussion.path
-            + (discussion.duplicateId ? '_' + discussion.duplicateId : '')
+exports.listDiscussions = function (aQuery, aParams, aBaseUrl, aCallback) {
+  listModels(Discussion, aQuery, aParams, ['updated', 'rating'],
+    function (aDiscussions, aDiscussionsList) {
+      aDiscussionsList.discussions = [];
+
+      aDiscussions.forEach(function (aDiscussion) {
+        aDiscussionsList.discussions.push({
+          topic: aDiscussion.topic,
+          comments: aDiscussion.comments,
+          author: aDiscussion.author,
+          created: aDiscussion.created,
+          lastCommentor: aDiscussion.author != aDiscussion.lastCommentor ?
+            aDiscussion.lastCommentor : null,
+          updated: formatDate(aDiscussion.updated),
+          rating: aDiscussion.rating,
+          url: aDiscussion.path
+            + (aDiscussion.duplicateId ? '_' + aDiscussion.duplicateId : '')
         });
       });
 
-      discussionsList.baseUrl = baseUrl + '/list';
-      callback(discussionsList);
+      aDiscussionsList.baseUrl = aBaseUrl + '/list';
+      aCallback(aDiscussionsList);
     });
 };
 
 // /list/size/:size/sort/:orderBy/dir/:direction/page/:page
 // Get a list of comments and build the options object
 // for the corresponding Mustache partial template
-exports.listComments = function (query, params, baseUrl, callback) {
-  listModels(Comment, query, params, ['created'],
-    function (comments, commentsList) {
-      commentsList.comments = [];
-
-      comments.forEach(function (comment) {
-        commentsList.comments.push({
-          author: comment.author,
-          content: renderMd(comment.content),
-          created: formatDate(comment.created),
-          rating: comment.rating,
-          id: comment.id,
+exports.listComments = function (aQuery, aParams, aBaseUrl, aCallback) {
+  listModels(Comment, aQuery, aParams, ['created'],
+    function (aComments, aCommentsList) {
+      aCommentsList.comments = [];
+
+      aComments.forEach(function (aComment) {
+        aCommentsList.comments.push({
+          author: aComment.author,
+          content: renderMd(aComment.content),
+          created: formatDate(aComment.created),
+          rating: aComment.rating,
+          id: aComment.id,
         });
       });
 
-      commentsList.baseUrl = baseUrl + '/list';
-      callback(commentsList);
+      aCommentsList.baseUrl = aBaseUrl + '/list';
+      aCallback(aCommentsList);
     });
 };
 
@@ -234,9 +234,9 @@ exports.listComments = function (query, params, baseUrl, callback) {
 //   size: (Number), orderBy: (String or Array or Object),
 //   direction: (String), page: (Number), omit: (Array)
 // }
-function listModels(model, query, options, defaultOrder, callback) {
+function listModels(aModel, aQuery, aOptions, aDefaultOrder, aCallback) {
   var optArr = null;
-  var fields = Object.keys(model.schema.tree);
+  var fields = Object.keys(aModel.schema.tree);
   var orderBy = null;
   var page = 0;
   var direction = 0;
@@ -245,46 +245,46 @@ function listModels(model, query, options, defaultOrder, callback) {
   var params = { sort: {} };
 
   // Either use route params or an object
-  if (options instanceof Array) {
-    optArr = options;
-    options = {};
-    options.size = optArr[0];
-    options.orderBy = optArr[1];
-    options.direction = optArr[2];
-    options.page = optArr[3];
-    options.omit = optArr[4];
+  if (aOptions instanceof Array) {
+    optArr = aOptions;
+    aOptions = {};
+    aOptions.size = optArr[0];
+    aOptions.orderBy = optArr[1];
+    aOptions.direction = optArr[2];
+    aOptions.page = optArr[3];
+    aOptions.omit = optArr[4];
   }
 
-  orderBy = options.orderBy || defaultOrder;
-  page = options.page && !isNaN(options.page) ? options.page - 1 : 0;
-  size = options.size || listSize;
+  orderBy = aOptions.orderBy || aDefaultOrder;
+  page = aOptions.page && !isNaN(aOptions.page) ? aOptions.page - 1 : 0;
+  size = aOptions.size || listSize;
 
   if (page < 0) { page = 0; }
 
   // Set the sort order for the model list
   if (typeof orderBy === 'string' && -1 !== fields.indexOf(orderBy)) {
-    direction = options.direction || model.schema.paths[orderBy]
+    direction = aOptions.direction || aModel.schema.paths[orderBy]
       .instance === 'String' ? 1 : -1;
     params.sort[orderBy] = direction;
   } else if (orderBy instanceof Array) {
-    orderBy.forEach(function (order) {
-      params.sort[order] = -1 !== fields.indexOf(order) &&
-        model.schema.paths[order].instance === 'String' ? 1 : -1;
+    orderBy.forEach(function (aOrder) {
+      params.sort[aOrder] = -1 !== fields.indexOf(aOrder) &&
+        aModel.schema.paths[aOrder].instance === 'String' ? 1 : -1;
     });
   } else if (typeof orderBy === 'object') {
     params.sort = orderBy;
   }
 
   // Omit certain fields from the models in the list
-  if (typeof options.omit === 'string') {
-    options.omit = options.omit.split(' ');
-  } else if (!options.omit) {
-    options.omit = [];
+  if (typeof aOptions.omit === 'string') {
+    aOptions.omit = aOptions.omit.split(' ');
+  } else if (!aOptions.omit) {
+    aOptions.omit = [];
   }
 
-  if (options.omit instanceof Array) {
-    options.omit.forEach(function (field) {
-      var index = fields.indexOf(field);
+  if (aOptions.omit instanceof Array) {
+    aOptions.omit.forEach(function (aField) {
+      var index = fields.indexOf(aField);
       if (index > -1) { fields.splice(index, 1); }
     });
     omit = fields.join(' ');
@@ -296,25 +296,25 @@ function listModels(model, query, options, defaultOrder, callback) {
     params.skip = size * page;
   }
 
-  model.find(query, omit, params,
-    function (err, models) {
+  aModel.find(aQuery, omit, params,
+    function (aErr, aModels) {
       var list = {};
-      if (!models) { models = [] }
-      if (size < 0) { size = models.length; }
+      if (!aModels) { aModels = [] }
+      if (size < 0) { size = aModels.length; }
       orderBy = typeof orderBy === 'string' ? orderBy : '';
       direction = direction === 1 ? 'asc' : 'desc';
 
       // Build the pagination for the Mustache template
-      list.size = options.size ? '/size/' + size : '';
-      list.orderBy = options.orderBy ? '/sort/' + orderBy : '';
-      list.direction = options.direction ? '/dir/' + direction : '';
+      list.size = aOptions.size ? '/size/' + size : '';
+      list.orderBy = aOptions.orderBy ? '/sort/' + orderBy : '';
+      list.direction = aOptions.direction ? '/dir/' + direction : '';
       page += 1;
 
       list.pageNumber = page;
-      list.next = models.length > size ? '/page/' + (page + 1) : '';
+      list.next = aModels.length > size ? '/page/' + (page + 1) : '';
       list.previous = page > 1 ? '/page/' + (page - 1) : '';
 
-      if (list.next) { models.pop(); }
-      callback(models, list);
+      if (list.next) { aModels.pop(); }
+      aCallback(aModels, list);
     });
 };
diff --git a/libs/modifySessions.js b/libs/modifySessions.js
index 28cdcbae6..4121e1d91 100644
--- a/libs/modifySessions.js
+++ b/libs/modifySessions.js
@@ -3,19 +3,19 @@
 // This library allows for the modifications of user sessions
 var async = require('async');
 
-exports.init = function (store) {
-  return function (req, res, next) {
+exports.init = function (aStore) {
+  return function (aReq, aRes, aNext) {
     // http://www.senchalabs.org/connect/session.html
     // Keep a reference to the session store on the request
     // so we can access and modify its data later
-    req.sessionStore = store;
-    next();
+    aReq.sessionStore = aStore;
+    aNext();
   };
 };
 
 // Serialize a user model to something that can be stored in the session data
-function serializeUser(user) {
-  var userObj = user.toObject();
+function serializeUser(aUser) {
+  var userObj = aUser.toObject();
 
   // Some things don't need to be kept in the session store
   // More could be removed (auths, strategies, flags, flagged?)
@@ -26,69 +26,69 @@ function serializeUser(user) {
 }
 
 // Add a new session id to the user model
-exports.add = function (req, user, callback) {
-  var store = req.sessionStore;
+exports.add = function (aReq, aUser, aCallback) {
+  var store = aReq.sessionStore;
 
-  function finish(err, user) {
-    req.session.user = serializeUser(user);
-    callback();
+  function finish(aErr, aUser) {
+    aReq.session.user = serializeUser(aUser); // TODO: Ambiguous
+    aCallback();
   }
 
   // Remove invalid session ids from user model
-  if (user.sessionIds && user.sessionIds.length > 0) {
-    async.filter(user.sessionIds, function (id, cb) {
-      store.get(id, function (err, sess) { cb(!err && sess); });
-    }, function (sessionIds) {
+  if (aUser.sessionIds && aUser.sessionIds.length > 0) {
+    async.filter(aUser.sessionIds, function (aId, aCb) {
+      store.get(aId, function (aErr, aSess) { aCb(!aErr && aSess); });
+    }, function (aSessionIds) {
       // No duplicates
-      if (sessionIds.indexOf(req.sessionID) === -1) {
-        sessionIds.push(req.sessionID);
+      if (aSessionIds.indexOf(aReq.sessionID) === -1) {
+        aSessionIds.push(aReq.sessionID);
       }
 
-      user.sessionIds = sessionIds;
-      user.save(finish);
+      aUser.sessionIds = aSessionIds; // TODO: Ambiguous
+      aUser.save(finish);
     });
   } else {
-    user.sessionIds = [req.sessionID];
-    user.save(finish);
+    aUser.sessionIds = [aReq.sessionID];
+    aUser.save(finish);
   }
 };
 
 // Remove a session id from the user model
-exports.remove = function (req, user, callback) {
-  var pos = user && user.sessionIds ?
-    user.sessionIds.indexOf(req.sessionID) : -1;
+exports.remove = function (aReq, aUser, aCallback) {
+  var pos = aUser && aUser.sessionIds ?
+    aUser.sessionIds.indexOf(aReq.sessionID) : -1;
 
-  delete req.session.user;
+  delete aReq.session.user;
 
   if (pos > -1) {
-    user.sessionIds.splice(pos, 1);
-    user.save(callback);
+    aUser.sessionIds.splice(pos, 1);
+    aUser.save(aCallback);
   } else {
-    callback();
+    aCallback();
   }
 };
 
 // Update all sessions for a user
-exports.update = function (req, user, callback) {
-  var store = req.sessionStore;
-  var userObj = user ? serializeUser(user) : null;
+exports.update = function (aReq, aUser, aCallback) {
+  var store = aReq.sessionStore;
+  var userObj = aUser ? serializeUser(aUser) : null;
 
-  if (!user || !user.sessionIds) { return callback('No sessions', null); }
+  if (!aUser || !aUser.sessionIds) { return aCallback('No sessions', null); }
 
-  async.each(user.sessionIds, function (id, cb) {
-    store.get(id, function (err, sess) {
+  async.each(aUser.sessionIds, function (aId, aCb) {
+    store.get(aId, function (aErr, aSess) {
       // Invalid session, will be removed on login
-      if (err || !sess) { return cb(null); }
+      if (aErr || !aSess) { return aCb(null); }
 
-      sess.user = userObj;
-      store.set(id, sess, cb);
+      aSess.user = userObj;
+      store.set(aId, aSess, aCb);
     });
-  }, callback);
+  }, aCallback);
 };
 
 // Destory all sessions for a user
-exports.destroy = function (req, user, callback) {
-  var store = req.sessionStore;
+exports.destroy = function (aReq, aUser, aCallback) {
+  var store = aReq.sessionStore;
   var emptySess = {
     cookie: {
       path: '/',
@@ -98,9 +98,9 @@ exports.destroy = function (req, user, callback) {
     }
   };
 
-  if (!user || !user.sessionIds) { return cb('No sessions', null); }
+  if (!aUser || !aUser.sessionIds) { return aCb('No sessions', null); }
 
-  async.each(user.sessionIds, function (id, cb) {
-    store.set(id, emptySess, cb);
-  }, callback);
+  async.each(aUser.sessionIds, function (aId, aCb) {
+    store.set(aId, emptySess, aCb);
+  }, aCallback);
 };
diff --git a/libs/muExpress.js b/libs/muExpress.js
index fecb4f544..da620708c 100644
--- a/libs/muExpress.js
+++ b/libs/muExpress.js
@@ -4,28 +4,28 @@ var mu = require('mu2');
 
 mu.root = __dirname + '/../views';
 
-function renderFile(res, path, options) {
+function renderFile(aRes, aPath, aOptions) {
   // If you need to render a file with a different content
   // type, do it directly on the response object
   if (process.env.NODE_ENV !== 'production') { mu.clearCache(); }
-  res.set('Content-Type', 'text/html; charset=UTF-8');
-  mu.compileAndRender(path, options).pipe(res);
+  aRes.set('Content-Type', 'text/html; charset=UTF-8');
+  mu.compileAndRender(aPath, aOptions).pipe(aRes);
 }
 
 // Express doesn't have stream support for rendering templates
 // Hack express to add support for rendering a template with Mu
-exports.renderFile = function (app) {
-  var render = app.response.__proto__.render;
+exports.renderFile = function (aApp) {
+  var render = aApp.response.__proto__.render;
 
-  app.response.__proto__.render = function (view, options, fn) {
+  aApp.response.__proto__.render = function (aView, aOptions, aFn) { // TODO: Short parm
     var self = this;
 
-    if (!fn && app.get('view engine') === 'html') {
-      fn = function (path, options) { renderFile(self, path, options); };
+    if (!aFn && aApp.get('view engine') === 'html') {
+      aFn = function (aPath, aOptions) { renderFile(self, aPath, aOptions); };
     }
 
-    render.call(self, view, options, fn);
+    render.call(self, aView, aOptions, aFn);
   };
 
-  return (function (path, options, fn) { fn(path, options); });
+  return (function (aPath, aOptions, aFn) { aFn(aPath, aOptions); });
 };
diff --git a/libs/passportLoader.js b/libs/passportLoader.js
index b37d312cb..e4fd51cab 100644
--- a/libs/passportLoader.js
+++ b/libs/passportLoader.js
@@ -14,15 +14,15 @@ exports.strategyInstances = nil();
 
 // This will load a single passport
 // Notice it is general so it can load any passport strategy
-exports.loadPassport = function (strategy) {
-  var requireStr = 'passport-' + strategy.name;
+exports.loadPassport = function (aStrategy) {
+  var requireStr = 'passport-' + aStrategy.name;
   var PassportStrategy = require(requireStr).Strategy;
   var instance = null;
 
-  if (strategy.openid) {
+  if (aStrategy.openid) {
     instance = new PassportStrategy(
       {
-        returnURL: AUTH_CALLBACK_BASE_URL + '/auth/' + strategy.name + '/callback/',
+        returnURL: AUTH_CALLBACK_BASE_URL + '/auth/' + aStrategy.name + '/callback/',
         realm: AUTH_CALLBACK_BASE_URL + '/',
         profile: false,
         stateless: true
@@ -32,17 +32,17 @@ exports.loadPassport = function (strategy) {
   } else {
     instance = new PassportStrategy(
       {
-        consumerKey: strategy.id,
-        consumerSecret: strategy.key,
-        clientID: strategy.id,
-        clientSecret: strategy.key,
+        consumerKey: aStrategy.id,
+        consumerSecret: aStrategy.key,
+        clientID: aStrategy.id,
+        clientSecret: aStrategy.key,
         state: 'a bullshit string reddit requires',
-        callbackURL: AUTH_CALLBACK_BASE_URL + '/auth/' + strategy.name + '/callback/'
+        callbackURL: AUTH_CALLBACK_BASE_URL + '/auth/' + aStrategy.name + '/callback/'
       },
       function () { } // we replace this callback later (_verify)
     );
   }
 
-  exports.strategyInstances[strategy.name] = instance;
+  exports.strategyInstances[aStrategy.name] = instance;
   passport.use(instance);
 };
diff --git a/libs/passportVerify.js b/libs/passportVerify.js
index 76ac65252..875a472e6 100644
--- a/libs/passportVerify.js
+++ b/libs/passportVerify.js
@@ -7,65 +7,65 @@ var userRoles = require('../models/userRoles.json');
 
 // This is a custom verification function used for Passports because
 // we needed something more powerful than what they provided
-exports.verify = function (id, strategy, username, loggedIn, done) {
+exports.verify = function (aId, aStrategy, aUsername, aLoggedIn, aDone) {
   var shasum = crypto.createHash('sha256');
   var digest = null;
 
   // We only keep plaintext ids for GH since that's all we need
-  if (strategy === 'github') {
-    digest = id;
+  if (aStrategy === 'github') {
+    digest = aId;
   } else {
     // Having these ids would allow us to do things with the user's
     // account and that is something we DO NOT want to do
-    shasum.update(String(id));
+    shasum.update(String(aId));
     digest = shasum.digest('hex');
   }
 
   findDeadorAlive(User, { 'auths': digest }, true,
-    function (alive, user, removed) {
-      var pos = user ? user.auths.indexOf(digest) : -1;
-      if (removed) { done(null, false, 'user was removed'); }
+    function (aAlive, aUser, aRemoved) {
+      var pos = aUser ? aUser.auths.indexOf(digest) : -1;
+      if (aRemoved) { aDone(null, false, 'user was removed'); }
 
-      if (!user) {
-        User.findOne({ 'name': username }, function (err, user) {
-          if (user && loggedIn) {
+      if (!aUser) {
+        User.findOne({ 'name': aUsername }, function (aErr, aUser) {
+          if (aUser && aLoggedIn) {
             // Add the new strategy to same account
             // This allows linking multiple external accounts to one of ours
-            user.auths.push(digest);
-            user.strategies.push(strategy);
-            user.save(function (err, user) {
-              return done(err, user);
+            aUser.auths.push(digest);
+            aUser.strategies.push(aStrategy);
+            aUser.save(function (aErr, aUser) {
+              return aDone(aErr, aUser);
             });
-          } else if (user) {
+          } else if (aUser) {
             // user was found matching name but not can't be authenticated
-            return done(null, false, 'username is taken');
+            return aDone(null, false, 'username is taken');
           } else {
             // Create a new user
-            user = new User({
-              'name': username,
+            aUser = new User({
+              'name': aUsername,
               'auths': [digest],
-              'strategies': [strategy],
+              'strategies': [aStrategy],
               'role': userRoles.length - 1,
               'about': '',
               'ghUsername': null
             });
-            user.save(function (err, user) {
-              return done(err, user);
+            aUser.save(function (aErr, aUser) {
+              return aDone(aErr, aUser);
             });
           }
         });
-      } else if (pos > -1 && pos < user.auths.length - 1) {
+      } else if (pos > -1 && pos < aUser.auths.length - 1) {
         // Set the default strategy
-        user.strategies.splice(pos, 1);
-        user.auths.splice(pos, 1);
-        user.strategies.push(strategy);
-        user.auths.push(digest);
-        user.save(function (err, user) {
-          return done(err, user);
+        aUser.strategies.splice(pos, 1);
+        aUser.auths.splice(pos, 1);
+        aUser.strategies.push(aStrategy);
+        aUser.auths.push(digest);
+        aUser.save(function (aErr, aUser) {
+          return aDone(aErr, aUser);
         });
       } else {
         // The user was authenticated
-        return done(null, user);
+        return aDone(null, aUser);
       }
     }
   );
diff --git a/libs/remove.js b/libs/remove.js
index 714162f6f..829611cc9 100644
--- a/libs/remove.js
+++ b/libs/remove.js
@@ -8,75 +8,75 @@ var async = require('async');
 var modelNames = ['Script'];
 var models = {};
 
-modelNames.forEach(function (modelName) {
-  models[modelName] = require('../models/' +
-    modelName.toLowerCase())[modelName];
+modelNames.forEach(function (aModelName) {
+  models[aModelName] = require('../models/' +
+    aModelName.toLowerCase())[aModelName];
 });
 
 // Determine whether content can be removed by a user.
-function removeable(model, content, user, callback) {
+function removeable(aModel, aContent, aUser, aCallback) {
   // The user must be logged in
   // The user is a moderator then the content must be flagged
   // If the user is an admin or greater then the content may be removed
-  if (!user || (!content.flagged && user.role > 3) || user.role > 2) {
-    return callback(false);
+  if (!aUser || (!aContent.flagged && aUser.role > 3) || aUser.role > 2) {
+    return aCallback(false);
   }
 
   // You can't remove yourself
   // You can only remove a remove a user with a lesser role than yourself
-  if (model.modelName === 'User') {
-    return callback(content._id != user._id && content.role > user.role,
-      content);
+  if (aModel.modelName === 'User') {
+    return aCallback(aContent._id != aUser._id && aContent.role > aUser.role,
+      aContent);
   }
 
-  User.findOne({ _id: content._authorId }, function (err, author) {
+  User.findOne({ _id: aContent._authorId }, function (aErr, aAuthor) {
     // Content without an author shouldn't exist
-    if (err || !author) { return callback(false); }
+    if (aErr || !aAuthor) { return aCallback(false); }
 
     // You can't remove your own content this way
     // When you remove your own content it's removed for good
-    if (author._id == user._id) { return callback(false, author); }
+    if (aAuthor._id == aUser._id) { return aCallback(false, aAuthor); }
 
     // You can only remove content by an author with a lesser user role
-    callback(author.role > user.role, author);
+    aCallback(aAuthor.role > aUser.role, aAuthor);
   });
 }
 exports.removeable = removeable;
 
-function remove(model, content, user, reason, callback) {
+function remove(aModel, aContent, aUser, aReason, aCallback) {
   var remove = new Remove({
-    'model': model.modelName,
-    'content': content.toObject(),
+    'model': aModel.modelName,
+    'content': aContent.toObject(),
     'removed': new Date(),
-    'reason': reason,
-    'removerName': user.name,
-    'removerRole': user.role,
-    '_removerId': user._id
+    'reason': aReason,
+    'removerName': aUser.name,
+    'removerRole': aUser.role,
+    '_removerId': aUser._id
   });
 
-  remove.save(function (err, remove) {
-    content.remove(function (err) { callback(remove); });
+  remove.save(function (aErr, aRemove) {
+    aContent.remove(function (aErr) { aCallback(aRemove); });
   });
 }
 
-exports.remove = function (model, content, user, reason, callback) {
-  removeable(model, content, user, function (canRemove, author) {
-    if (!canRemove) { return callback(false); }
+exports.remove = function (aModel, aContent, aUser, aReason, aCallback) {
+  removeable(aModel, aContent, aUser, function (aCanRemove, aAuthor) {
+    if (!aCanRemove) { return aCallback(false); }
 
-    if (model.modelName !== 'User') {
-      remove(model, content, user, reason, callback);
+    if (aModel.modelName !== 'User') {
+      remove(aModel, aContent, aUser, aReason, aCallback);
     } else {
       // Remove all the user's content
-      async.each(modelNames, function (modelName, cb) {
-        var model = models[modelName];
-        model.find({ _authorId: content._id },
-          function (err, contentArr) {
-            async.each(contentArr, function (content, innerCb) {
-              remove(model, content, user, null, innerCb);
-            }, cb);
+      async.each(modelNames, function (aModelName, aCallback) {
+        var model = models[aModelName];
+        model.find({ _authorId: aContent._id },
+          function (aErr, aContentArr) {
+            async.each(aContentArr, function (aContent, innerCb) {
+              remove(model, aContent, aUser, null, innerCb);
+            }, aCallback);
           });
       }, function () {
-        remove(model, content, user, reason, callback);
+        remove(aModel, aContent, aUser, aReason, aCallback);
       });
     }
   });
@@ -98,29 +98,29 @@ exports.remove = function (model, content, user, reason, callback) {
 //
 // The removed parameter is the Remove document containing the content
 // and is always returned if found, regardless of permissions.
-exports.findDeadorAlive = function (model, query, user, callback) {
-  var modelName = model.modelName;
+exports.findDeadorAlive = function (aModel, aQuery, aUser, aCallback) {
+  var modelName = aModel.modelName;
 
-  model.findOne(query, function (err, content) {
+  aModel.findOne(aQuery, function (aErr, aContent) {
     var name = null;
     var rmQuery = { model: modelName };
 
-    if (!err && content) { return callback(true, content, null); }
+    if (!aErr && aContent) { return aCallback(true, aContent, null); }
     if (modelName != 'User' && -1 === modelNames.indexOf(modelName)) {
-      return callback(null, null, null);
+      return aCallback(null, null, null);
     }
 
-    for (name in query) {
-      rmQuery['content.' + name] = query[name];
+    for (name in aQuery) {
+      rmQuery['content.' + name] = aQuery[name];
     }
 
-    Remove.findOne(rmQuery, function (err, removed) {
-      if (err || !removed) { return callback(null, null, null); }
-      if (!user || (user !== true && user.role > removed.removerRole)) {
-        return callback(false, null, removed);
+    Remove.findOne(rmQuery, function (aErr, aRemoved) {
+      if (aErr || !aRemoved) { return aCallback(null, null, null); }
+      if (!aUser || (aUser !== true && aUser.role > aRemoved.removerRole)) {
+        return aCallback(false, null, aRemoved);
       }
 
-      callback(false, new model(removed.content), removed);
+      aCallback(false, new model(aRemoved.content), aRemoved); // TODO: Ambiguous
     });
   });
 };
diff --git a/libs/repoManager.js b/libs/repoManager.js
index 2dde1199c..7f9c6951f 100644
--- a/libs/repoManager.js
+++ b/libs/repoManager.js
@@ -14,29 +14,29 @@ var github = require('../libs/githubClient');
 var clientId = null;
 var clientKey = null;
 
-Strategy.findOne({ name: 'github' }, function (err, strat) {
-  clientId = strat.id;
-  clientKey = strat.key;
+Strategy.findOne({ name: 'github' }, function (aErr, aStrat) {
+  clientId = aStrat.id;
+  clientKey = aStrat.key;
 });
 
 // Requests a GitHub url and returns the chunks as buffers
-function fetchRaw(host, path, callback) {
+function fetchRaw(aHost, aPath, aCallback) {
   var options = {
-    hostname: host,
+    hostname: aHost,
     port: 443,
-    path: path,
+    path: aPath,
     method: 'GET',
     headers: { 'User-Agent': 'Node.js' }
   };
 
   var req = https.request(options,
-    function (res) {
+    function (aRes) {
       var bufs = [];
-      if (res.statusCode != 200) { console.log(res.statusCode); return callback([new Buffer('')]); }
+      if (aRes.statusCode != 200) { console.log(aRes.statusCode); return aCallback([new Buffer('')]); }
       else {
-        res.on('data', function (d) { bufs.push(d); });
-        res.on('end', function () {
-          callback(bufs);
+        aRes.on('data', function (aD) { bufs.push(aD); }); // TODO: Short parm
+        aRes.on('end', function () {
+          aCallback(bufs);
         });
       }
     });
@@ -45,73 +45,73 @@ function fetchRaw(host, path, callback) {
 
 // Use for call the GitHub JSON api
 // Returns the JSON parsed object
-function fetchJSON(path, callback) {
-  path += '?client_id=' + clientId + '&client_secret=' + clientKey;
-  fetchRaw('api.github.com', path, function (bufs) {
-    callback(JSON.parse(Buffer.concat(bufs).toString()));
+function fetchJSON(aPath, aCallback) {
+  aPath += '?client_id=' + clientId + '&client_secret=' + clientKey;
+  fetchRaw('api.github.com', aPath, function (aBufs) {
+    aCallback(JSON.parse(Buffer.concat(aBufs).toString()));
   });
 }
 
 // This manages actions on the repos of a user
-function RepoManager(userId, user, repos) {
-  this.userId = userId;
-  this.user = user;
-  this.repos = repos || nil();
+function RepoManager(aUserId, aUser, aRepos) {
+  this.userId = aUserId;
+  this.user = aUser;
+  this.repos = aRepos || nil();
 }
 
 // Fetches the information about repos that contain user scripts
-RepoManager.prototype.fetchRecentRepos = function (callback) {
+RepoManager.prototype.fetchRecentRepos = function (aCallback) {
   var repoList = [];
   var that = this;
 
   async.waterfall([
-    function (callback) {
+    function (aCallback) {
       github.repos.getFromUser({
         user: encodeURIComponent(that.userId),
         sort: 'updated',
         order: 'desc',
         per_page: 3,
-      }, callback);
+      }, aCallback);
     },
-    function (githubRepoList, callback) {
+    function (aGithubRepoList, aCallback) {
       // Don't search through forks
       // to speedup this request.
-      // githubRepoList = _.where(githubRepoList, {fork: false});
+      // aGithubRepoList = _.where(aGithubRepoList, {fork: false});
 
-      _.map(githubRepoList, function (githubRepo) {
-        repoList.push(new Repo(that, githubRepo.owner.login, githubRepo.name));
+      _.map(aGithubRepoList, function (aGithubRepo) {
+        repoList.push(new Repo(that, aGithubRepo.owner.login, aGithubRepo.name));
       });
 
-      async.each(repoList, function (repo, callback) {
-        repo.fetchUserScripts(function () {
-          callback(null);
+      async.each(repoList, function (aRepo, aCallback) {
+        aRepo.fetchUserScripts(function () {
+          aCallback(null);
         });
-      }, callback);
+      }, aCallback);
     },
-  ], callback);
+  ], aCallback);
 };
 
 // Import scripts on GitHub
-RepoManager.prototype.loadScripts = function (callback, update) {
+RepoManager.prototype.loadScripts = function (aCallback, aUpdate) {
   var scriptStorage = require('../controllers/scriptStorage');
   var arrayOfRepos = this.makeRepoArray();
   var that = this;
   var scripts = [];
 
   // TODO: remove usage of makeRepoArray since it causes redundant looping
-  arrayOfRepos.forEach(function (repo) {
-    async.each(repo.scripts, function (script, cb) {
-      var url = '/' + encodeURI(repo.user) + '/' + encodeURI(repo.repo)
-        + '/master' + script.path;
-      fetchRaw('raw.githubusercontent.com', url, function (bufs) {
-        scriptStorage.getMeta(bufs, function (meta) {
-          if (meta) {
-            scriptStorage.storeScript(that.user, meta, Buffer.concat(bufs),
-              cb, update);
+  arrayOfRepos.forEach(function (aRepo) {
+    async.each(aRepo.scripts, function (aScript, aCallback) {
+      var url = '/' + encodeURI(aRepo.user) + '/' + encodeURI(aRepo.repo)
+        + '/master' + aScript.path;
+      fetchRaw('raw.githubusercontent.com', url, function (aBufs) {
+        scriptStorage.getMeta(aBufs, function (aMeta) {
+          if (aMeta) {
+            scriptStorage.storeScript(that.user, aMeta, Buffer.concat(aBufs),
+              aCallback, aUpdate);
           }
         });
       });
-    }, callback);
+    }, aCallback);
   });
 }
 
@@ -141,55 +141,55 @@ RepoManager.prototype.makeRepoArray = function () {
 }
 
 // Manages a single repo
-function Repo(manager, username, reponame) {
-  this.manager = manager;
-  this.user = username;
-  this.repo = reponame;
+function Repo(aManager, aUsername, aReponame) {
+  this.manager = aManager;
+  this.user = aUsername;
+  this.repo = aReponame;
 }
 
 // Use recursive requests to locate all user scripts in a repo
-Repo.prototype.fetchUserScripts = function (callback) {
-  this.getTree('HEAD', '', callback);
+Repo.prototype.fetchUserScripts = function (aCallback) {
+  this.getTree('HEAD', '', aCallback);
 };
 
 // Looks for user script in the current directory
 // and initiates searches on subdirectories
-Repo.prototype.parseTree = function (tree, path, done) {
+Repo.prototype.parseTree = function (aTree, aPath, aDone) {
   var object;
   var trees = [];
   var that = this;
   var repos = this.manager.repos;
 
-  tree.forEach(function (object) {
+  aTree.forEach(function (object) {
     if (object.type === 'tree') {
       trees.push({
-        sha: object.sha, path: path + '/'
+        sha: object.sha, path: aPath + '/'
           + encodeURI(object.path)
       });
     } else if (object.path.substr(-8) === '.user.js') {
       if (!repos[that.repo]) { repos[that.repo] = nil(); }
-      repos[that.repo][object.path] = path + '/' + encodeURI(object.path);
+      repos[that.repo][object.path] = aPath + '/' + encodeURI(object.path);
     }
   });
 
-  async.each(trees, function (tree, cb) {
-    that.getTree(tree.sha, tree.path, cb);
+  async.each(trees, function (aTree, aCallback) {
+    that.getTree(aTree.sha, aTree.path, aCallback);
   }, function () {
-    done();
+    aDone();
   });
 };
 
 // Gets information about a directory
-Repo.prototype.getTree = function (sha, path, cb) {
+Repo.prototype.getTree = function (aSha, aPath, aCallback) {
   var that = this;
   fetchJSON('/repos/' + encodeURI(this.user) + '/' + encodeURI(this.repo)
-    + '/git/trees/' + sha,
-    function (json) {
-      that.parseTree(json.tree, path, cb);
+    + '/git/trees/' + aSha,
+    function (aJson) {
+      that.parseTree(aJson.tree, aPath, aCallback);
     }
   );
 };
 
-exports.getManager = function (userId, user, repos) {
-  return new RepoManager(userId, user, repos);
+exports.getManager = function (aUserId, aUser, aRepos) {
+  return new RepoManager(aUserId, aUser, aRepos);
 };
diff --git a/libs/tasks.js b/libs/tasks.js
index a935d8d12..ac0281210 100644
--- a/libs/tasks.js
+++ b/libs/tasks.js
@@ -2,36 +2,36 @@
 
 var defaultOnErrFn = console.log;
 
-var onErr = function (err, onErrFn) {
-  if (onErrFn)
-    onErrFn(err);
+var onErr = function (aErr, aOnErrFn) {
+  if (aOnErrFn)
+    aOnErrFn(aErr);
   else
-    defaultOnErrFn(err);
+    defaultOnErrFn(aErr);
 };
 
-exports.countTask = function (modelListQuery, dict, key, onErrFn) {
-  return function (callback) {
-    modelListQuery.model.count(modelListQuery._conditions, function (err, modelListCount) {
-      if (err) {
-        onErr(err, onErrFn);
-        callback();
+exports.countTask = function (aModelListQuery, aDict, aKey, aOnErrFn) {
+  return function (aCallback) {
+    aModelListQuery.model.count(aModelListQuery._conditions, function (aErr, aModelListCount) {
+      if (aErr) {
+        onErr(aErr, aOnErrFn);
+        aCallback();
       } else {
-        dict[key] = modelListCount;
-        callback();
+        aDict[aKey] = aModelListCount;
+        aCallback();
       }
     });
   };
 };
 
-exports.execQueryTask = function (query, dict, key, onErrFn) {
-  return function (callback) {
-    query.exec(function (err, result) {
-      if (err) {
-        onErr(err, onErrFn);
-        callback();
+exports.execQueryTask = function (aQuery, aDict, aKey, aOnErrFn) {
+  return function (aCallback) {
+    aQuery.exec(function (aErr, result) {
+      if (aErr) {
+        onErr(aErr, aOnErrFn);
+        aCallback();
       } else {
-        dict[key] = result
-        callback();
+        aDict[aKey] = result
+        aCallback();
       }
     });
   };
diff --git a/libs/templateHelpers.js b/libs/templateHelpers.js
index d16100933..6f1eb284b 100644
--- a/libs/templateHelpers.js
+++ b/libs/templateHelpers.js
@@ -5,16 +5,16 @@ var helpers = require('../libs/helpers');
 var modelParser = require('../libs/modelParser');
 var _ = require('underscore');
 
-var paginateTemplate = function (opts) {
+var paginateTemplate = function (aOpts) {
   // Required
-  var currentPage = opts.currentPage;
-  var lastPage = opts.lastPage;
-  var urlFn = opts.urlFn;
+  var currentPage = aOpts.currentPage;
+  var lastPage = aOpts.lastPage;
+  var urlFn = aOpts.urlFn;
 
   // Optional
-  var distVisible = opts.distVisible || 4;
-  var firstVisible = opts.firstVisible || true;
-  var lastVisible = opts.firstVisible || true;
+  var distVisible = aOpts.distVisible || 4;
+  var firstVisible = aOpts.firstVisible || true;
+  var lastVisible = aOpts.firstVisible || true;
 
   var linkedPages = [];
 
@@ -47,7 +47,7 @@ var paginateTemplate = function (opts) {
 };
 exports.paginateTemplate = paginateTemplate;
 
-var newPagination = function (currentPage, itemsPerPage) {
+var newPagination = function (aCurrentPage, aItemsPerPage) {
   // Options
   var maxItemsPerPage = 100;
   var defaultItemsPerPage = 25;
@@ -59,33 +59,33 @@ var newPagination = function (currentPage, itemsPerPage) {
     startIndex: null,
     numItems: null
   };
-  pagination.applyToQuery = function (modelListQuery) {
+  pagination.applyToQuery = function (aModelListQuery) {
     pagination.startIndex = (pagination.currentPage * pagination.itemsPerPage) - pagination.itemsPerPage;
-    modelListQuery
+    aModelListQuery
       .skip(pagination.startIndex)
       .limit(pagination.itemsPerPage);
   };
-  pagination.getCountTask = function (modelListQuery) {
-    return countTask(modelListQuery, pagination, 'numItems');
+  pagination.getCountTask = function (aModelListQuery) {
+    return countTask(aModelListQuery, pagination, 'numItems');
   };
   pagination.render = function () {
     return paginateTemplate(pagination);
   };
 
   //
-  pagination.currentPage = currentPage ? helpers.limitMin(1, currentPage) : 1;
-  pagination.itemsPerPage = itemsPerPage ? helpers.limitRange(1, itemsPerPage, maxItemsPerPage) : defaultItemsPerPage;
+  pagination.currentPage = aCurrentPage ? helpers.limitMin(1, aCurrentPage) : 1;
+  pagination.itemsPerPage = aItemsPerPage ? helpers.limitRange(1, aItemsPerPage, maxItemsPerPage) : defaultItemsPerPage;
 
   return pagination;
 };
 exports.newPagination = newPagination;
 
-var getDefaultPagination = function (req) {
-  var pagination = newPagination(req.query.p, req.query.limit);
-  pagination.renderDefault = function (req) {
+var getDefaultPagination = function (aReq) {
+  var pagination = newPagination(aReq.query.p, aReq.query.limit);
+  pagination.renderDefault = function (aReq) {
     pagination.lastPage = Math.ceil(pagination.numItems / pagination.itemsPerPage) || 1;
-    pagination.urlFn = function (p) {
-      return helpers.setUrlQueryValue(req.url, 'p', p);
+    pagination.urlFn = function (aP) { // TODO: Short parameter
+      return helpers.setUrlQueryValue(aReq.url, 'p', aP);
     };
     return pagination.render();
   };
@@ -93,46 +93,46 @@ var getDefaultPagination = function (req) {
 };
 exports.getDefaultPagination = getDefaultPagination;
 
-exports.statusCodePage = function (req, res, next, options) {
-  var authedUser = req.session ? req.session.user : null;
+exports.statusCodePage = function (aReq, aRes, aNext, aOptions) {
+  var authedUser = aReq.session ? aReq.session.user : null;
 
   //
-  options.statusCode = options.statusCode || 500;
-  options.statusMessage = options.statusMessage || 'Error';
+  aOptions.statusCode = aOptions.statusCode || 500;
+  aOptions.statusMessage = aOptions.statusMessage || 'Error';
 
   // Session
-  authedUser = options.authedUser = modelParser.parseUser(authedUser);
-  options.isMod = authedUser && authedUser.isMod;
-  options.isAdmin = authedUser && authedUser.isAdmin;
+  authedUser = aOptions.authedUser = modelParser.parseUser(authedUser);
+  aOptions.isMod = authedUser && authedUser.isMod;
+  aOptions.isAdmin = authedUser && authedUser.isAdmin;
 
   // Page metadata
-  pageMetadata(options, [options.statusCode, options.statusMessage], options.statusMessage);
+  pageMetadata(aOptions, [aOptions.statusCode, aOptions.statusMessage], aOptions.statusMessage);
 
   //---
-  res.status(options.statusCode).render('pages/statusCodePage', options);
+  aRes.status(aOptions.statusCode).render('pages/statusCodePage', aOptions);
 };
 
 // Add page metadata, containing title, description and keywords.
-function pageMetadata(options, title, description, keywords) {
+function pageMetadata(aOptions, aTitle, aDescription, aKeywords) {
   var titles = ['OpenUserJS'];
-  if (typeof (title) === "string" && title !== "") {
-    titles.unshift(title);
-  } else if (_.isArray(title)) {
-    titles = title.concat(titles);
+  if (typeof (aTitle) === "string" && aTitle !== "") {
+    titles.unshift(aTitle);
+  } else if (_.isArray(aTitle)) {
+    titles = aTitle.concat(titles);
   }
-  options.title = titles.join(' | ');
+  aOptions.aTitle = titles.join(' | ');
 
-  options.pageMetaDescription = 'Download userscripts to enhance your browser.';
-  if (typeof (description) !== "undefined" && description !== null) {
-    options.pageMetaDescription = description;
+  aOptions.pageMetaDescription = 'Download userscripts to enhance your browser.';
+  if (typeof (aDescription) !== "undefined" && aDescription !== null) {
+    aOptions.pageMetaDescription = aDescription;
   }
 
   var pageMetaKeywords = ['userscript', 'userscripts', 'javascript', 'Greasemonkey', 'Scriptish',
     'Tampermonkey', 'extension', 'browser'];
-  if (typeof (keywords) !== "undefined" && keywords !== null && _.isArray(keywords)) {
-    pageMetaKeywords = _.union(pageMetaKeywords, keywords);
+  if (typeof (aKeywords) !== "undefined" && aKeywords !== null && _.isArray(aKeywords)) {
+    pageMetaKeywords = _.union(pageMetaKeywords, aKeywords);
   }
 
-  options.pageMetaKeywords = pageMetaKeywords.join(', ');
+  aOptions.pageMetaKeywords = pageMetaKeywords.join(', ');
 }
 exports.pageMetadata = pageMetadata;
diff --git a/views/includes/scripts/commentReplyScript.html b/views/includes/scripts/commentReplyScript.html
index 346430a82..9c6ca1b01 100644
--- a/views/includes/scripts/commentReplyScript.html
+++ b/views/includes/scripts/commentReplyScript.html
@@ -1,9 +1,9 @@
 <script type="text/javascript">
 
-  $('.btn-comment-reply').click(function (e){
+  $('.btn-comment-reply').click(function (aE){
     $('#reply-control').collapse('show');
 
-    var $comment = $(e.target).closest('.topic-post');
+    var $comment = $(aE.target).closest('.topic-post');
     var $author = $comment.find('.topic-meta-data .names .username').first();
     var $replyTextarea = $('#reply-control textarea[name="comment-content"]');
 
@@ -19,13 +19,13 @@
     $replyTextarea.text(text);
   });
 
-  function isElementInViewport (el) {
+  function isElementInViewport (aEl) {
     //special bonus for those using jQuery
-    if (el instanceof jQuery) {
-      el = el[0];
+    if (aEl instanceof jQuery) {
+      aEl = aEl[0];
     }
 
-    var rect = el.getBoundingClientRect();
+    var rect = aEl.getBoundingClientRect();
 
     return (
       rect.top >= 0 &&
@@ -36,17 +36,17 @@
   }
 
   var hasShownReplyForm = false;
-  function callback (el) {
+  function callback (aEl) {
     if (!hasShownReplyForm) {
       $('#reply-control').collapse('show');
       hasShownReplyForm = true;
     }
   }
 
-  function fireIfElementVisible (el, callback) {
+  function fireIfElementVisible (aEl, aCallback) {
     return function () {
-      if ( isElementInViewport(el) ) {
-        callback(el);
+      if ( isElementInViewport(aEl) ) {
+        aCallback(aEl);
       }
     }
   }
diff --git a/views/includes/scripts/tableTrLinkScript.html b/views/includes/scripts/tableTrLinkScript.html
index ea32be91b..0a4f0c2b1 100644
--- a/views/includes/scripts/tableTrLinkScript.html
+++ b/views/includes/scripts/tableTrLinkScript.html
@@ -1,8 +1,8 @@
 <script>
   $(document).ready(function (){
     // https://stackoverflow.com/questions/4904938/link-entire-table-row
-    $('.tr-link').click(function (e){
-      if ($(e.target).is('a,input,a *')) // anything else you don't want to trigger the click
+    $('.tr-link').click(function (aE){
+      if ($(aE.target).is('a,input,a *')) // anything else you don't want to trigger the click
         return;
 
       var a = $(this).find('a.tr-link-a').first();
@@ -10,7 +10,7 @@
       var url = a.attr('href');
       if (!url) return;
       window.location = url;
-      e.stopPropagation();
+      aE.stopPropagation();
     })
   });
 </script>
diff --git a/views/pages/scriptEditMetadataPage.html b/views/pages/scriptEditMetadataPage.html
index 0dfa2b108..9c1cd4faf 100644
--- a/views/pages/scriptEditMetadataPage.html
+++ b/views/pages/scriptEditMetadataPage.html
@@ -57,8 +57,8 @@ <h2>Description</h2>
   <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/select2/3.4.8/select2.min.js"></script>
   <script type="text/javascript">
     var preload_groups = {{{groupNameListJSON}}};
-    var preload_data = $.map(preload_groups, function (group) {
-      return { id: group, text: group, locked: true };
+    var preload_data = $.map(preload_groups, function (aGroup) {
+      return { id: aGroup, text: aGroup, locked: true };
     });
     $(document).ready(function () {
       var canAddGroup = true;
@@ -68,8 +68,8 @@ <h2>Description</h2>
       $('#groups').select2({
         multiple: true,
         minimumInputLength: 1,
-        query: function (query){
-          var url = '/api/group/search/' + encodeURIComponent(query.term);
+        query: function (aQuery){
+          var url = '/api/group/search/' + encodeURIComponent(aQuery.term);
 
           if (canCreateGroup) {
             if (canAddGroup) {
@@ -77,22 +77,22 @@ <h2>Description</h2>
                 && $('#groups').val().split(',').indexOf(prevTerm) > -1) {
                 canAddGroup = false;
               } else {
-                prevTerm = query.term;
+                prevTerm = aQuery.term;
               }
             } else if ($('#groups').val().split(',').indexOf(prevTerm) === -1) {
-              prevTerm = query.term;
+              prevTerm = aQuery.term;
               canAddGroup = true;
             }
 
             url += '/' + (canAddGroup ? 'true' : '');
           }
 
-          $.ajax({ url: url, success: function (data) {
+          $.ajax({ url: url, success: function (aData) {
             var groups = { results: [] };
-            $.each(data, function (index, group) {
+            $.each(aData, function (index, group) {
               groups.results.push({ id: group, text: group });
             });
-            query.callback(groups);
+            aQuery.callback(groups);
           }});
         }});
       $('#groups').select2('data', preload_data);
diff --git a/views/scriptEdit.html b/views/scriptEdit.html
index fdb468687..9c5d08bef 100644
--- a/views/scriptEdit.html
+++ b/views/scriptEdit.html
@@ -5,8 +5,8 @@
 <script type="text/javascript" src="/js/select2.min.js"></script>
 <script type="text/javascript">
   var preload_groups = {{{groups}}};
-  var preload_data = $.map(preload_groups, function (group) {
-    return { id: group, text: group, locked: true };
+  var preload_data = $.map(preload_groups, function (aGroup) {
+    return { id: aGroup, text: aGroup, locked: true };
   });
   $(document).ready(function () {
     var canAddGroup = true;
@@ -16,8 +16,8 @@
     $('#groups').select2({
       multiple: true,
       minimumInputLength: 1,
-      query: function (query){
-        var url = '/api/group/search/' + encodeURIComponent(query.term);
+      query: function (aQuery){
+        var url = '/api/group/search/' + encodeURIComponent(aQuery.term);
 
         if (canCreateGroup) {
           if (canAddGroup) {
@@ -25,22 +25,22 @@
               && $('#groups').val().split(',').indexOf(prevTerm) > -1) {
               canAddGroup = false;
             } else {
-              prevTerm = query.term;
+              prevTerm = aQuery.term;
             }
           } else if ($('#groups').val().split(',').indexOf(prevTerm) === -1) {
-            prevTerm = query.term;
+            prevTerm = aQuery.term;
             canAddGroup = true;
           }
 
           url += '/' + (canAddGroup ? 'true' : '');
         }
 
-        $.ajax({ url: url, success: function (data) {
+        $.ajax({ url: url, success: function (aData) {
           var groups = { results: [] };
-          $.each(data, function (index, group) {
-            groups.results.push({ id: group, text: group });
+          $.each(aData, function (aIndex, aGroup) {
+            groups.results.push({ id: aGroup, text: aGroup });
           });
-          query.callback(groups);
+          aQuery.callback(groups);
         }});
       }});
     $('#groups').select2('data', preload_data);