Remove usages of jquery and add sugar.js from garden-o-matic.

Tools/GardeningServer/scripts/results.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 83 matching lines @@
 
     function pushTextSuffixes()
     {
         suffixList.push(kActualTextSuffix);
         suffixList.push(kExpectedTextSuffix);
         suffixList.push(kDiffTextSuffix);
         // '-wdiff.html',
         // '-pretty-diff.html',
     }
 
-    $.each(failureTypeList, function(index, failureType) {
+    failureTypeList.forEach(function(failureType) {
         switch(failureType) {
         case IMAGE:
             pushImageSuffixes();
             break;
         case TEXT:
             pushTextSuffixes();
             break;
         case AUDIO:
             pushAudioSuffixes();
             break;
@@ skipping 100 matching lines @@
 
 results.unexpectedFailures = function(resultsTree)
 {
     return base.filterTree(resultsTree.tests, isResultNode, isUnexpectedFailure);
 };
 
 function resultsByTest(resultsByBuilder, filter)
 {
     var resultsByTest = {};
 
-    $.each(resultsByBuilder, function(builderName, resultsTree) {
-        $.each(filter(resultsTree), function(testName, resultNode) {
+    Object.keys(resultsByBuilder, function(builderName, resultsTree) {
+        Object.keys(filter(resultsTree), function(testName, resultNode) {
             resultsByTest[testName] = resultsByTest[testName] || {};
             resultsByTest[testName][builderName] = resultNode;
         });
     });
 
     return resultsByTest;
 }
 
 results.unexpectedFailuresByTest = function(resultsByBuilder)
 {
     return resultsByTest(resultsByBuilder, results.unexpectedFailures);
 };
 
 results.failureInfoForTestAndBuilder = function(resultsByTest, testName, builderName)
 {
     var failureInfoForTest = {
         'testName': testName,
         'builderName': builderName,
         'failureTypeList': failureTypeList(resultsByTest[testName][builderName].actual),
     };
 
     return failureInfoForTest;
 };
 
 results.collectUnexpectedResults = function(dictionaryOfResultNodes)
 {
     var collectedResults = [];
-    $.each(dictionaryOfResultNodes, function(key, resultNode) {
+    Object.keys(dictionaryOfResultNodes, function(key, resultNode) {
         var analyzer = new results.ResultAnalyzer(resultNode);
         collectedResults = collectedResults.concat(analyzer.unexpectedResults());
     });
     return base.uniquifyArray(collectedResults);
 };
 
 // Callback data is [{ buildNumber:, url: }]
 function historicalResultsLocations(builderName)
 {
     return builders.mostRecentBuildForBuilder(builderName).then(function (mostRecentBuildNumber) {
@@ skipping 18 matching lines @@
     function continueWalk()
     {
         if (indexOfNextKeyToFetch >= keyList.length) {
             processResultNode(0, null);
             return;
         }
 
         var resultsURL = keyList[indexOfNextKeyToFetch].url;
         ++indexOfNextKeyToFetch;
         g_resultsCache.get(resultsURL).then(function(resultsTree) {
-            if ($.isEmptyObject(resultsTree)) {
+            if (!Object.size(resultsTree)) {
                 continueWalk();
                 return;
             }
             var resultNode = results.resultNodeForTest(resultsTree, testName);
             var revision = parseInt(resultsTree['blink_revision']);
             if (isNaN(revision))
                 revision = 0;
             processResultNode(revision, resultNode);
         });
     }
@@ skipping 40 matching lines @@
     });
 };
 
 function mergeRegressionRanges(regressionRanges)
 {
     var mergedRange = {};
 
     mergedRange.oldestFailingRevision = 0;
     mergedRange.newestPassingRevision = 0;
 
-    $.each(regressionRanges, function(builderName, range) {
+    Object.keys(regressionRanges, function(builderName, range) {
         if (!range.oldestFailingRevision && !range.newestPassingRevision)
             return
 
         if (!mergedRange.oldestFailingRevision)
             mergedRange.oldestFailingRevision = range.oldestFailingRevision;
         if (!mergedRange.newestPassingRevision)
             mergedRange.newestPassingRevision = range.newestPassingRevision;
 
         if (range.oldestFailingRevision && range.oldestFailingRevision < mergedRange.oldestFailingRevision)
             mergedRange.oldestFailingRevision = range.oldestFailingRevision;
         if (range.newestPassingRevision > mergedRange.newestPassingRevision)
             mergedRange.newestPassingRevision = range.newestPassingRevision;
     });
 
     return mergedRange;
 }
 
 results.unifyRegressionRanges = function(builderNameList, testName) {
     var regressionRanges = {};
 
     var rangePromises = [];
-    $.each(builderNameList, function(index, builderName) {
+    builderNameList.forEach(function(builderName) {
         rangePromises.push(results.regressionRangeForFailure(builderName, testName)
                            .then(function(result) {
                                var oldestFailingRevision = result[0];
                                var newestPassingRevision = result[1];
                                var range = {};
                                range.oldestFailingRevision = oldestFailingRevision;
                                range.newestPassingRevision = newestPassingRevision;
                                regressionRanges[builderName] = range;
                            }));
     });
     return Promise.all(rangePromises).then(function() {
         var mergedRange = mergeRegressionRanges(regressionRanges);
         return [mergedRange.oldestFailingRevision, mergedRange.newestPassingRevision];
     });
 };
 
 results.resultNodeForTest = function(resultsTree, testName)
 {
     var testNamePath = testName.split('/');
     var currentNode = resultsTree['tests'];
-    $.each(testNamePath, function(index, segmentName) {
+    testNamePath.forEach(function(segmentName) {
         if (!currentNode)
             return;
         currentNode = (segmentName in currentNode) ? currentNode[segmentName] : null;
     });
     return currentNode;
 };
 
 results.resultKind = function(url)
 {
     if (/-actual\.[a-z]+$/.test(url))
@@ skipping 10 matching lines @@
     if (/\.png$/.test(url))
         return results.kImageType;
     if (/\.wav$/.test(url))
         return results.kAudioType;
     return results.kTextType;
 }
 
 function sortResultURLsBySuffix(urls)
 {
     var sortedURLs = [];
-    $.each(kPreferredSuffixOrder, function(i, suffix) {
-        $.each(urls, function(j, url) {
+    kPreferredSuffixOrder.forEach(function(suffix) {
+        urls.forEach(function(url) {
             if (!base.endsWith(url, suffix))
                 return;
             sortedURLs.push(url);
         });
     });
     if (sortedURLs.length != urls.length)
         throw "sortResultURLsBySuffix failed to return the same number of URLs.";
     return sortedURLs;
 }
 
 results.fetchResultsURLs = function(failureInfo)
 {
     var testNameStem = base.trimExtension(failureInfo.testName);
     var urlStem = resultsDirectoryURL(failureInfo.builderName);
 
     var suffixList = possibleSuffixListFor(failureInfo.failureTypeList);
     var resultURLs = [];
     var probePromises = [];
-    $.each(suffixList, function(index, suffix) {
+    suffixList.forEach(function(suffix) {
         var url = urlStem + testNameStem + suffix;
         probePromises.push(net.probe(url).then(
             function() {
                 resultURLs.push(url);
             },
             function() {}));
     });
     return Promise.all(probePromises).then(function() {
         return sortResultURLsBySuffix(resultURLs);
     });
 };
 
 results.fetchResultsByBuilder = function(builderNameList)
 {
     var resultsByBuilder = {};
     var fetchPromises = [];
-    $.each(builderNameList, function(index, builderName) {
+    builderNameList.forEach(function(builderName) {
         var resultsURL = resultsSummaryURL(builderName);
         fetchPromises.push(net.jsonp(resultsURL).then(function(resultsTree) {
             resultsByBuilder[builderName] = resultsTree;
         }));
     });
     return Promise.all(fetchPromises).then(function() {
         return resultsByBuilder;
     });
 };
 
 })();