Merge pull request #244 from alice/ignore-selectors-fix

Ignore selectors fix

Author: Alice

src/js/AuditRule.js

@@ -125,11 +125,23 @@ axs.AuditRule.prototype.addElement = function(elements, element) {
   * @param {Node} scope
   * @param {function(Element): boolean} matcher
   * @param {Array.<Element>} collection
+  * @param {Array.<string>=} opt_ignoreSelectors
   */
-axs.AuditRule.collectMatchingElements = function(scope, matcher, collection) {
+axs.AuditRule.collectMatchingElements = function(scope, matcher, collection, opt_ignoreSelectors) {
+    /**
+     * @param {!Element} element
+     * @return boolean
+     */
     function relevantElementCollector(element) {
+        if (opt_ignoreSelectors) {
+            for (var i = 0; i < opt_ignoreSelectors.length; i++) {
+                if (axs.browserUtils.matchSelector(element, opt_ignoreSelectors[i]))
+                    return false;
+            }
+        }
         if (matcher(element))
             collection.push(element);
+        return true;
     }
     axs.dom.composedTreeSearch(scope, null, { preorder: relevantElementCollector });
 };
@@ -149,30 +161,21 @@ axs.AuditRule.collectMatchingElements = function(scope, matcher, collection) {
  */
 axs.AuditRule.prototype.run = function(options) {
     options = options || {};
-    var ignoreSelectors = 'ignoreSelectors' in options ? options['ignoreSelectors'] : [];
     var scope = 'scope' in options ? options['scope'] : document;
     var maxResults = 'maxResults' in options ? options['maxResults'] : null;
 
     var relevantElements = [];
-    axs.AuditRule.collectMatchingElements(scope, this.relevantElementMatcher_, relevantElements);
+    axs.AuditRule.collectMatchingElements(scope, this.relevantElementMatcher_, relevantElements, options['ignoreSelectors']);
 
     var failingElements = [];
 
-    function ignored(element) {
-        for (var i = 0; i < ignoreSelectors.length; i++) {
-            if (axs.browserUtils.matchSelector(element, ignoreSelectors[i]))
-                return true;
-        }
-        return false;
-    }
-
     if (!relevantElements.length)
         return { result: axs.constants.AuditResult.NA };
     for (var i = 0; i < relevantElements.length; i++) {
         if (maxResults != null && failingElements.length >= maxResults)
             break;
         var element = relevantElements[i];
-        if (!ignored(element) && this.test_(element, options.config))
+        if (this.test_(element, options.config))
             this.addElement(failingElements, element);
     }
     var result = failingElements.length ? axs.constants.AuditResult.FAIL : axs.constants.AuditResult.PASS;

src/js/DOMUtils.js

@@ -108,11 +108,12 @@ axs.dom.asElement = function(node) {
  * Recursively walk the composed tree from |node|, aborting if |end| is encountered.
  * @param {Node} node
  * @param {?Node} end
- * @param {{preorder: (function (Node)|undefined),
+ * @param {{preorder: (function (Node):boolean|undefined),
  *          postorder: (function (Node)|undefined)}} callbacks
  *     Callbacks to be called for each element traversed, excluding
  *     |end|. Possible callbacks are |preorder|, called before descending into
  *     child nodes, and |postorder| called after all child nodes have been
+ *     traversed. If |preorder| returns false, its child nodes will not be
  *     traversed.
  * @param {ShadowRoot=} opt_shadowRoot The nearest ShadowRoot ancestor, if any.
  * @return {boolean} Whether |end| was found, if provided.
@@ -124,11 +125,13 @@ axs.dom.composedTreeSearch = function(node, end, callbacks, opt_shadowRoot) {
     if (node.nodeType == Node.ELEMENT_NODE)
         var element = /** @type {Element} */ (node);
 
-    if (element && callbacks.preorder)
-        callbacks.preorder(element);
-
     var found = false;
 
+    if (element && callbacks.preorder) {
+        if (!callbacks.preorder(element))
+            return found;
+    }
+
     // Descend into node:
     // If it has a ShadowRoot, ignore all child elements - these will be picked
     // up by the <content> or <shadow> elements. Descend straight into the

test/audits/aria-on-reserved-element-test.js

@@ -78,7 +78,7 @@
         var widget = fixture.appendChild(document.createElement('meta'));
         var ignoreSelectors = ['#' + (widget.id = 'ignoreMe')];
         widget.setAttribute('aria-hidden', 'false');  // global
-        var expected = { elements: [], result: axs.constants.AuditResult.PASS };
+        var expected = { result: axs.constants.AuditResult.NA };
         deepEqual(rule.run({ scope: fixture, ignoreSelectors: ignoreSelectors }), expected, 'ignoreSelectors should skip this failing element');
     });
 

test/audits/aria-owns-descendant-test.js

@@ -86,7 +86,6 @@
         var result = rule.run({
             ignoreSelectors: ignoreSelectors,
             scope: fixture });
-        equal(result.result, axs.constants.AuditResult.PASS);
-        deepEqual(result.elements, []);
+        equal(result.result, axs.constants.AuditResult.NA);
     });
 })();

test/audits/multiple-aria-owners-test.js

@@ -104,7 +104,6 @@
         var result = rule.run({
             ignoreSelectors: ignoreSelectors,
             scope: fixture });
-        equal(result.result, axs.constants.AuditResult.PASS);
-        deepEqual(result.elements, []);
+        equal(result.result, axs.constants.AuditResult.NA);
     });
 })();

test/audits/non-existent-aria-related-element-test.js

@@ -115,6 +115,6 @@ module('NonExistentAriaRelatedElement');
         var rule = axs.AuditRules.getRule('nonExistentAriaRelatedElement');
         var ignoreSelectors = ['#labelledbyElement2'];
         var result = rule.run({ ignoreSelectors: ignoreSelectors, scope: fixture });
-        equal(result.result, axs.constants.AuditResult.PASS);
+        equal(result.result, axs.constants.AuditResult.NA);
     });
 });

test/js/audit-rule-test.js

@@ -28,6 +28,7 @@
         for (var i = 0; i < DIV_COUNT; i++) {
             var element = document.createElement("div");
             element.className = "test";
+            element.id = "test-" + i;
             result.appendChild(element);
         }
         return result;
@@ -41,6 +42,21 @@
         equal(matched.length, DIV_COUNT);
     });
 
+    test("Simple DOM with an ignored selector", function () {
+        var container = document.getElementById('qunit-fixture');
+        container.appendChild(buildTestDom());
+        var fooElement = document.createElement('div');
+        fooElement.className = 'foo';
+        container.appendChild(fooElement);
+        var fooTest = document.createElement('div');
+        fooTest.className = 'test';
+        fooElement.appendChild(fooTest);
+        var matched = [];
+        var ignoredSelectors = ['.foo'];
+        axs.AuditRule.collectMatchingElements(container, matcher, matched, ignoredSelectors);
+        equal(matched.length, DIV_COUNT);
+    });
+
     test("With shadow DOM with no content insertion point", function () {
         var container = document.getElementById('qunit-fixture');
         container.appendChild(buildTestDom());