rebaseline_server: allow substring filtering for builder and test

gm/rebaseline_server/static/loader.js

 /*
  * Loader:
  * Reads GM result reports written out by results.py, and imports
  * them into $scope.categories and $scope.testData .
  */
 var Loader = angular.module(
     'Loader',
     []
 );
 
 
 // TODO(epoger): Combine ALL of our filtering operations (including
 // truncation) into this one filter, so that runs most efficiently?
 // (We would have to make sure truncation still took place after
 // sorting, though.)
 Loader.filter(
   'removeHiddenItems',
   function() {
     return function(unfilteredItems, hiddenResultTypes, hiddenConfigs,
-                    viewingTab) {
+                    builderSubstring, testSubstring, viewingTab) {
       var filteredItems = [];
       for (var i = 0; i < unfilteredItems.length; i++) {
         var item = unfilteredItems[i];
         // For performance, we examine the "set" objects directly rather
         // than calling $scope.isValueInSet().
         // Besides, I don't think we have access to $scope in here...
         if (!(true == hiddenResultTypes[item.resultType]) &&
             !(true == hiddenConfigs[item.config]) &&
+            !(-1 == item.builder.indexOf(builderSubstring)) &&
+            !(-1 == item.test.indexOf(testSubstring)) &&
             (viewingTab == item.tab)) {
           filteredItems.push(item);
         }
       }
       return filteredItems;
     };
   }
 );
 
 
@@ skipping 53 matching lines @@
 
         // Arrays within which the user can toggle individual elements.
         $scope.selectedItems = [];
 
         // Sets within which the user can toggle individual elements.
         $scope.hiddenResultTypes = {
           'failure-ignored': true,
           'no-comparison': true,
           'succeeded': true,
         };
+        $scope.allResultTypes = Object.keys(data.categories['resultType']);
         $scope.hiddenConfigs = {};
+        $scope.allConfigs = Object.keys(data.categories['config']);
+
+        // Associative array of partial string matches per category.
+        $scope.categoryValueMatch = {};
+        $scope.categoryValueMatch.builder = "";
+        $scope.categoryValueMatch.test = "";
 
         $scope.updateResults();
         $scope.loadingMessage = "";
         $scope.windowTitle = "Current GM Results";
       }
     ).error(
       function(data, status, header, config) {
         $scope.loadingMessage = "Failed to load results of type '"
             + resultsToLoad + "'";
         $scope.windowTitle = "Failed to Load GM Results";
@@ skipping 119 matching lines @@
       // the items as they are displayed, rather than storing multiple
       // array copies?  (For better performance.)
 
       if ($scope.viewingTab == $scope.defaultTab) {
         $scope.filteredTestData =
             $filter("orderBy")(
                 $filter("removeHiddenItems")(
                     $scope.testData,
                     $scope.hiddenResultTypes,
                     $scope.hiddenConfigs,
+                    $scope.categoryValueMatch.builder,
+                    $scope.categoryValueMatch.test,
                     $scope.viewingTab
                 ),
                 $scope.sortColumn);
         $scope.limitedTestData = $filter("limitTo")(
             $scope.filteredTestData, $scope.displayLimit);
       } else {
         $scope.filteredTestData =
             $filter("orderBy")(
                 $filter("filter")(
                     $scope.testData,
@@ skipping 10 matching lines @@
     /**
      * Re-sort the displayed results.
      *
      * @param sortColumn (string): name of the column to sort on
      */
     $scope.sortResultsBy = function(sortColumn) {
       $scope.sortColumn = sortColumn;
       $scope.updateResults();
     }
 
+    /**
+     * Set $scope.categoryValueMatch[name] = value, and update results.
+     *
+     * @param name
+     * @param value
+     */
+    $scope.setCategoryValueMatch = function(name, value) {
+      $scope.categoryValueMatch[name] = value;
+      $scope.updateResults();
+    }
+
+    /**
+     * Update $scope.hiddenResultTypes so that ONLY this resultType is showing,
+     * and update the visible results.
+     *
+     * @param resultType
+     */
+    $scope.showOnlyResultType = function(resultType) {
+      $scope.hiddenResultTypes = {};
+      $scope.toggleValuesInSet($scope.allResultTypes, $scope.hiddenResultTypes);
+      $scope.toggleValueInSet(resultType, $scope.hiddenResultTypes);

[borenet, 2013/10/29 13:56:54]

I'm confused about why you're using these toggle functions instead of just
adding and subtracting...

[epoger, 2013/10/29 15:44:58]

Because they're different data types.  Added a TODO.

+      $scope.updateResults();
+    }
+
+    /**
+     * Update $scope.hiddenConfigs so that ONLY this config is showing,
+     * and update the visible results.
+     *
+     * @param config
+     */
+    $scope.showOnlyConfig = function(config) {
+      $scope.hiddenConfigs = {};
+      $scope.toggleValuesInSet($scope.allConfigs, $scope.hiddenConfigs);
+      $scope.toggleValueInSet(config, $scope.hiddenConfigs);
+      $scope.updateResults();
+    }
+
 
     //
     // Operations for sending info back to the server.
     //
 
     /**
      * Tell the server that the actual results of these particular tests
      * are acceptable.
      *
      * @param testDataSubset an array of test results, most likely a subset of
@@ skipping 103 matching lines @@
      * @param set an Object which we use to mimic set semantics
      */
     $scope.toggleValueInSet = function(value, set) {
       if (true == set[value]) {
         delete set[value];
       } else {
         set[value] = true;
       }
     }
 
+    /**
+     * For each value in valueArray, call toggleValueInSet(value, set).
+     *
+     * @param valueArray
+     * @param set
+     */
+    $scope.toggleValuesInSet = function(valueArray, set) {
+      var arrayLength = valueArray.length;
+      for (var i = 0; i < arrayLength; i++) {
+        $scope.toggleValueInSet(valueArray[i], set);
+      }
+    }
+
 
     //
     // Array operations; similar to our Set operations, but operate on a
     // Javascript Array so we *can* easily get a list of all values in the Set.
     // TODO(epoger): move into a separate .js file?
     //
 
     /**
      * Returns true if value "value" is present within array "array".
      *
@@ skipping 32 matching lines @@
      *
      * @param secondsPastEpoch (numeric): seconds past epoch in UTC
      */
     $scope.localTimeString = function(secondsPastEpoch) {
       var d = new Date(secondsPastEpoch * 1000);
       return d.toString();
     }
 
   }
 );