Added handling of whitelisting rules like @@||example.com^$document

lib/matcher.js

 /*
  * This file is part of the Adblock Plus extension,
  * Copyright (C) 2006-2012 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
@@ skipping 18 matching lines @@
 
   var WhitelistFilter = null;
   var RegExpFilter = null;
   var resourceTypes = [
       "FONT", "IMAGE", "MEDIA", "OBJECT", "OBJECT_SUBREQUEST",
       "OTHER", "SCRIPT", "STYLESHEET", "SUBDOCUMENT", "XMLHTTPREQUEST"
   ];
 
   require.scopes.matcher =
   {
+    init: function()
+    {
+      WhitelistFilter = require("filterClasses").WhitelistFilter;
+      RegExpFilter = require("filterClasses").RegExpFilter;
+    },
+
     defaultMatcher:
     {
       _rules: {},
       _domainExceptions: {},
       _domainExceptionsTimeout: null,
 
       /**
        * Converts rule text from Adblock Plus format (implicit * at beginning
        * and end of the rule unless there is an anchor) to Opera format (* has
        * to be specified explicitly).
@@ skipping 98 matching lines @@
           options: {
             resources: this._getRuleTypes(filter)
           }
         };
         this._getRuleDomains(filter, rule.options);
         this._getRuleThirdParty(filter, rule.options);
         return rule;
       },
 
       /**
-       * Extracts the domain to which the exception applies if any.
-       */
-      _getDomainFromException: function(/**Filter*/ filter) /**String*/
-      {
-        if (filter.domainSource)
-          return null;
+       * Checks whether the filter is a domain exception and adds/removes it
+       * according to the add parameter. Returns true if a domain exception
+       * has been processed, false otherwise.
+       */
+      _processDomainException: function(/**Filter*/ filter, /**Boolean*/ add) /**Boolean*/
+      {
+        if (!(filter instanceof WhitelistFilter) ||
+            filter.contentType != RegExpFilter.typeMap.DOCUMENT ||
+            filter.domainSource)
+        {
+          return false;
+        }
 
         var match = /^\|\|([^\/]+)\^$/.exec(filter.regexpSource);
         if (!match)
-          return null;
-
-        return match[1];
-      },
-
-      /**
-       * Adds a global exception for a particular document domain.
-       */
-      _addDomainException: function(/**String*/ domain)
-      {
-        this._domainExceptions[domain] = true;
-
-        // Update domain exceptions rule delayed to prevent multiple subsequent
-        // updates.
+          return false;
+
+        var domain = match[1];
+        if (add)
+          this._domainExceptions[domain] = true;
+        else
+          delete this._domainExceptions[domain];
+
+        this._updateDomainExceptions();
+        return true;
+      },
+
+      /**
+       * Updates domain exceptions rule, execution happens delayed to prevent
+       * multiple subsequent updates.
+       */
+      _updateDomainExceptions: function()
+      {
         if (this._domainExceptionsTimeout)
           window.clearTimeout(this._domainExceptionsTimeout);
-        this._domainExceptionsTimeout = window.setTimeout(this._updateDomainExceptions.bind(this), 0);
-      },
-
-      /**
-       * Removes a global exception for a particular document domain.
-       */
-      _removeDomainException: function(/**String*/ domain)
-      {
-        delete this._domainExceptions[domain];
-
-        // Update domain exceptions rule delayed to prevent multiple subsequent
-        // updates.
-        if (this._domainExceptionsTimeout)
-          window.clearTimeout(this._domainExceptionsTimeout);
-        this._domainExceptionsTimeout = window.setTimeout(this._updateDomainExceptions.bind(this), 0);
-      },
-
-      /**
-       * Updates domain exceptions rule (should be called delayed).
-       */
-      _updateDomainExceptions: function()
-      {
-        this._domainExceptionsTimeout = null;
-        opera.extension.urlfilter.allow.remove("*:*");
-
-        var domains = Object.keys(this._domainExceptions);
-        if (domains.length)
-        {
-          opera.extension.urlfilter.allow.add("*:*", {
-            includeDomains: domains
-          });
-        }
+
+        this._domainExceptionsTimeout = window.setTimeout(function()
+        {
+          this._domainExceptionsTimeout = null;
+          opera.extension.urlfilter.allow.remove("*:*");
+
+          var domains = Object.keys(this._domainExceptions);
+          if (domains.length)
+          {
+            opera.extension.urlfilter.allow.add("*:*", {
+              includeDomains: domains
+            });
+          }
+        }.bind(this), 0);
       },
 
       add: function(filter)
       {
-        if (!WhitelistFilter)

[Felix Dahlke, 2012/11/14 13:03:51]

Not a new problem, but can't we do this earlier? Both remove and _generateRule
rely on add being executed first. (Arguably less of a problem with
_generateRule, since it's only invoked from add.)

[Wladimir Palant, 2012/11/14 13:46:53]

Yes, it's ugly. Problem is that matcher.js needs to be included before
background.js - meaning that it cannot just require() its dependencies while
loading. Let's try a different hack...

-        {
-          WhitelistFilter = require("filterClasses").WhitelistFilter;
-          RegExpFilter = require("filterClasses").RegExpFilter;
-        }
-
-        if (filter instanceof WhitelistFilter && filter.contentType == RegExpFilter.typeMap.DOCUMENT)

[Felix Dahlke, 2012/11/14 13:03:51]

I'd like a function for both this check and the _getDomainFromException call
below, since we have the same code in remove.

Maybe something like this:

var whitelistedDomain = this._getWhitelistedDomain(filter);
if (whitelistedDomain)
  this._addDomainException(whitelistedDomain); // or remove, respectively

[Wladimir Palant, 2012/11/14 13:46:53]

Ok, I changed the solution to have maximal code reuse.

-        {
-          var domain = this._getDomainFromException(filter);
-          if (domain)
-            this._addDomainException(domain);
-        }
+        if (this._processDomainException(filter, true))
+          return;
 
         if (filter.text in this._rules)
           return;
 
         if (!filter.regexpSource) // Regular expressions aren't supported
           return;
 
         var rule = this._generateRule(filter);
         opera.extension.urlfilter[rule.type].add(rule.text, rule.options);
         this._rules[filter.text] = rule;
       },
 
       remove: function(filter)
       {
-        if (filter instanceof WhitelistFilter && filter.contentType == RegExpFilter.typeMap.DOCUMENT)
-        {
-          var domain = this._getDomainFromException(filter);
-          if (domain)
-            this._removeDomainException(domain);
-        }
+        if (this._processDomainException(filter, false))
+          return;
 
         if (!(filter.text in this._rules))
           return;
 
         var rule = this._rules[filter.text];
         opera.extension.urlfilter[rule.type].remove(rule.text);
         delete this._rules[filter.text];
       },
 
       clear: function()
       {
         for (var text in this._rules)
         {
           var rule = this._rules[text];
           opera.extension.urlfilter[rule.type].remove(rule.text);
         }
         this._rules = {};
 
-        for (var domain in this._domainExceptions)
-          this._removeDomainException(domain);
         this._domainExceptions = {};
+        this._updateDomainExceptions();
       }
     }
   };
 })();