Issue 6665 - Split out element hiding exceptions into their own module

lib/elemHide.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 /**
  * @fileOverview Element hiding implementation.
  */
 
-const {ElemHideException} = require("./filterClasses");
+const {ElemHideExceptions} = require("./elemHideExceptions");
 const {FilterNotifier} = require("./filterNotifier");
 
 /**
  * Lookup table, active flag, by filter by domain.
  * (Only contains filters that aren't unconditionally matched for all domains.)
  * @type {Map.<string,Map.<Filter,boolean>>}
  */
 let filtersByDomain = new Map();
 
 /**
@@ skipping 12 matching lines @@
 let unconditionalSelectors = null;
 
 /**
  * Map to be used instead when a filter has a blank domains property.
  * @type {Map.<string,boolean>}
  * @const
  */
 let defaultDomains = new Map([["", true]]);
 
 /**
- * Set containing known element hiding and exception filters
- * @type {Set.<ElemHideBase>}
+ * Set containing known element hiding filters
+ * @type {Set.<ElemHideFilter>}
  */
 let knownFilters = new Set();
 
 /**
- * Lookup table, lists of element hiding exceptions by selector
- * @type {Map.<string,Filter[]>}
- */
-let exceptions = new Map();
-
-/**
  * Adds a filter to the lookup table of filters by domain.
  * @param {Filter} filter
  */
 function addToFiltersByDomain(filter)
 {
   let domains = filter.domains || defaultDomains;
   for (let [domain, isIncluded] of domains)
   {
     // There's no need to note that a filter is generically disabled.
     if (!isIncluded && domain == "")
@@ skipping 11 matching lines @@
  * @returns {string[]}
  */
 function getUnconditionalSelectors()
 {
   if (!unconditionalSelectors)
     unconditionalSelectors = [...filterBySelector.keys()];
 
   return unconditionalSelectors;
 }
 
+ElemHideExceptions.on("added", ({selector}) =>
+{
+  // If this is the first exception for a previously unconditionally applied
+  // element hiding selector we need to take care to update the lookups.
+  let unconditionalFilterForSelector = filterBySelector.get(selector);
+  if (unconditionalFilterForSelector)
+  {
+    addToFiltersByDomain(unconditionalFilterForSelector);
+    filterBySelector.delete(selector);
+    unconditionalSelectors = null;
+  }
+
+  FilterNotifier.emit("elemhideupdate");
+});
+
+ElemHideExceptions.on("removed", () =>
+{
+  FilterNotifier.emit("elemhideupdate");
+});
+
 /**
  * Container for element hiding filters
  * @class
  */
 exports.ElemHide = {
   /**
    * Removes all known filters
    */
   clear()
   {
     for (let collection of [filtersByDomain, filterBySelector,
-                            knownFilters, exceptions])
+                            knownFilters])
     {
       collection.clear();
     }
     unconditionalSelectors = null;
     FilterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Add a new element hiding filter
-   * @param {ElemHideBase} filter
+   * @param {ElemHideFilter} filter
    */
   add(filter)
   {
     if (knownFilters.has(filter))
       return;
 
-    if (filter instanceof ElemHideException)
-    {
-      let {selector} = filter;
-      let list = exceptions.get(selector);
-      if (list)
-        list.push(filter);
-      else
-        exceptions.set(selector, [filter]);
-
-      // If this is the first exception for a previously unconditionally
-      // applied element hiding selector we need to take care to update the
-      // lookups.
-      let unconditionalFilterForSelector = filterBySelector.get(selector);
-      if (unconditionalFilterForSelector)
-      {
-        addToFiltersByDomain(unconditionalFilterForSelector);
-        filterBySelector.delete(selector);
-        unconditionalSelectors = null;
-      }
-    }
-    else if (!(filter.domains || exceptions.has(filter.selector)))
+    if (!(filter.domains || ElemHideExceptions.hasExceptions(filter.selector)))
     {
       // The new filter's selector is unconditionally applied to all domains
       filterBySelector.set(filter.selector, filter);
       unconditionalSelectors = null;
     }
     else
     {
       // The new filter's selector only applies to some domains
       addToFiltersByDomain(filter);
     }
 
     knownFilters.add(filter);
     FilterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Removes an element hiding filter
-   * @param {ElemHideBase} filter
+   * @param {ElemHideFilter} filter
    */
   remove(filter)
   {
     if (!knownFilters.has(filter))
       return;
 
-    // Whitelisting filters
-    if (filter instanceof ElemHideException)
-    {
-      let list = exceptions.get(filter.selector);
-      let index = list.indexOf(filter);
-      if (index >= 0)
-        list.splice(index, 1);
-    }
     // Unconditially applied element hiding filters
-    else if (filterBySelector.get(filter.selector) == filter)
+    if (filterBySelector.get(filter.selector) == filter)
     {
       filterBySelector.delete(filter.selector);
       unconditionalSelectors = null;
     }
     // Conditionally applied element hiding filters
     else
     {
       let domains = filter.domains || defaultDomains;
       for (let domain of domains.keys())
       {
         let filters = filtersByDomain.get(domain);
         if (filters)
           filters.delete(filter);
       }
     }
 
     knownFilters.delete(filter);
     FilterNotifier.emit("elemhideupdate");
   },
 
   /**
-   * Checks whether an exception rule is registered for a filter on a particular
-   * domain.
-   * @param {Filter} filter
-   * @param {?string} docDomain
-   * @return {?ElemHideException}
-   */
-  getException(filter, docDomain)
-  {
-    let list = exceptions.get(filter.selector);
-    if (!list)
-      return null;
-
-    for (let i = list.length - 1; i >= 0; i--)
-    {
-      if (list[i].isActiveOnDomain(docDomain))
-        return list[i];
-    }
-
-    return null;
-  },
-
-  /**
    * Determines from the current filter list which selectors should be applied
    * on a particular host name.
    * @param {string} domain
    * @param {boolean} [specificOnly] true if generic filters should not apply.
    * @returns {string[]} List of selectors.
    */
   getSelectorsForDomain(domain, specificOnly = false)
   {
     let selectors = [];
 
@@ skipping 10 matching lines @@
       let filters = filtersByDomain.get(currentDomain);
       if (filters)
       {
         for (let [filter, isIncluded] of filters)
         {
           if (!isIncluded)
           {
             excluded.add(filter);
           }
           else if ((excluded.size == 0 || !excluded.has(filter)) &&
-                   !this.getException(filter, domain))
+                   !ElemHideExceptions.getException(filter, domain))
           {
             selectors.push(filter.selector);
           }
         }
       }
 
       if (currentDomain == "")
         break;
 
       let nextDot = currentDomain.indexOf(".");
       currentDomain = nextDot == -1 ? "" : currentDomain.substr(nextDot + 1);
     }
 
     if (!specificOnly)
       selectors = getUnconditionalSelectors().concat(selectors);
 
     return selectors;
   }
 };