Issue 6733 - Allow empty values in filter options

lib/filterClasses.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
@@ skipping 222 matching lines @@
   return beforeOptions + "$" + options.join();
 };
 
 /**
  * @see filterToRegExp
  */
 Filter.toRegExp = filterToRegExp;
 
 /**
  * Class for invalid filters
- * @param {string} text see Filter()
+ * @param {string} text see {@link Filter Filter()}
  * @param {string} reason Reason why this filter is invalid
  * @constructor
  * @augments Filter
  */
 function InvalidFilter(text, reason)
 {
   Filter.call(this, text);
 
   this.reason = reason;
 }
@@ skipping 10 matching lines @@
 
   /**
    * See Filter.serialize()
    * @inheritdoc
    */
   serialize(buffer) {}
 });
 
 /**
  * Class for comments
- * @param {string} text see Filter()
+ * @param {string} text see {@link Filter Filter()}
  * @constructor
  * @augments Filter
  */
 function CommentFilter(text)
 {
   Filter.call(this, text);
 }
 exports.CommentFilter = CommentFilter;
 
 CommentFilter.prototype = extend(Filter, {
   type: "comment",
 
   /**
    * See Filter.serialize()
    * @inheritdoc
    */
   serialize(buffer) {}
 });
 
 /**
  * Abstract base class for filters that can get hits
  * @param {string} text
- *   see Filter()
+ *   see {@link Filter Filter()}
  * @param {string} [domains]
  *   Domains that the filter is restricted to separated by domainSeparator
  *   e.g. "foo.com|bar.com|~baz.com"
  * @constructor
  * @augments Filter
  */
 function ActiveFilter(text, domains)
 {
   Filter.call(this, text);
 
@@ skipping 72 matching lines @@
   domainSource: null,
 
   /**
    * Separator character used in domainSource property, must be
    * overridden by subclasses
    * @type {string}
    */
   domainSeparator: null,
 
   /**
-   * Determines whether domainSource is already upper-case,
+   * Determines whether domainSource is already lower-case,
    * can be overridden by subclasses.
    * @type {boolean}
    */
-  domainSourceIsUpperCase: false,
+  domainSourceIsLowerCase: false,
 
   /**
    * Map containing domains that this filter should match on/not match
    * on or null if the filter should match on all domains
    * @type {?Map.<string,boolean>}
    */
   get domains()
   {
     let domains = null;
 
     if (this.domainSource)
     {
       let source = this.domainSource;
-      if (!this.domainSourceIsUpperCase)
+      if (!this.domainSourceIsLowerCase)
       {
-        // RegExpFilter already have uppercase domains
-        source = source.toUpperCase();
+        // RegExpFilter already have lowercase domains
+        source = source.toLowerCase();
       }
       let list = source.split(this.domainSeparator);
       if (list.length == 1 && list[0][0] != "~")
       {
         // Fast track for the common one-domain scenario
         domains = new Map([["", false], [list[0], true]]);
       }
       else
       {
         let hasIncludes = false;
@@ skipping 56 matching lines @@
 
     // If no domains are set the rule matches everywhere
     if (!this.domains)
       return true;
 
     // If the document has no host name, match only if the filter
     // isn't restricted to specific domains
     if (!docDomain)
       return this.domains.get("");
 
-    docDomain = docDomain.replace(/\.+$/, "").toUpperCase();
+    docDomain = docDomain.replace(/\.+$/, "").toLowerCase();
 
     while (true)
     {
       let isDomainIncluded = this.domains.get(docDomain);
       if (typeof isDomainIncluded != "undefined")
         return isDomainIncluded;
 
       let nextDot = docDomain.indexOf(".");
       if (nextDot < 0)
         break;
       docDomain = docDomain.substr(nextDot + 1);
     }
     return this.domains.get("");
   },
 
   /**
    * Checks whether this filter is active only on a domain and its subdomains.
    * @param {string} docDomain
    * @return {boolean}
    */
   isActiveOnlyOnDomain(docDomain)
   {
     if (!docDomain || !this.domains || this.domains.get(""))
       return false;
 
-    docDomain = docDomain.replace(/\.+$/, "").toUpperCase();
+    docDomain = docDomain.replace(/\.+$/, "").toLowerCase();
 
     for (let [domain, isIncluded] of this.domains)
     {
       if (isIncluded && domain != docDomain)
       {
         if (domain.length <= docDomain.length)
           return false;
 
         if (!domain.endsWith("." + docDomain))
           return false;
@@ skipping 27 matching lines @@
       if (this._hitCount)
         buffer.push("hitCount=" + this._hitCount);
       if (this._lastHit)
         buffer.push("lastHit=" + this._lastHit);
     }
   }
 });
 
 /**
  * Abstract base class for RegExp-based filters
- * @param {string} text see Filter()
+ * @param {string} text see {@link Filter Filter()}
  * @param {string} regexpSource
  *   filter part that the regular expression should be build from
  * @param {number} [contentType]
  *   Content types the filter applies to, combination of values from
  *   RegExpFilter.typeMap
  * @param {boolean} [matchCase]
  *   Defines whether the filter should distinguish between lower and upper case
  *   letters
  * @param {string} [domains]
  *   Domains that the filter is restricted to, e.g. "foo.com|bar.com|~baz.com"
  * @param {boolean} [thirdParty]
  *   Defines whether the filter should apply to third-party or first-party
  *   content only
  * @param {string} [sitekeys]
  *   Public keys of websites that this filter should apply to
  * @constructor
  * @augments ActiveFilter
  */
 function RegExpFilter(text, regexpSource, contentType, matchCase, domains,
                       thirdParty, sitekeys)
 {
   ActiveFilter.call(this, text, domains, sitekeys);
 
   if (contentType != null)
     this.contentType = contentType;
   if (matchCase)
     this.matchCase = matchCase;
   if (thirdParty != null)
     this.thirdParty = thirdParty;
-  if (sitekeys)
+  if (sitekeys != null)
     this.sitekeySource = sitekeys;
 
   if (regexpSource.length >= 2 &&
       regexpSource[0] == "/" &&
       regexpSource[regexpSource.length - 1] == "/")
   {
     // The filter is a regular expression - convert it immediately to
     // catch syntax errors
     let regexp = new RegExp(regexpSource.substr(1, regexpSource.length - 2),
                             this.matchCase ? "" : "i");
     Object.defineProperty(this, "regexp", {value: regexp});
   }
   else
   {
     // No need to convert this filter to regular expression yet, do it on demand
     this.regexpSource = regexpSource;
   }
 }
 exports.RegExpFilter = RegExpFilter;
 
 RegExpFilter.prototype = extend(ActiveFilter, {
   /**
-   * @see ActiveFilter.domainSourceIsUpperCase
-   */
-  domainSourceIsUpperCase: true,
+   * @see ActiveFilter.domainSourceIsLowerCase
+   */
+  domainSourceIsLowerCase: true,
 
   /**
    * Number of filters contained, will always be 1 (required to
    * optimize Matcher).
    * @type {number}
    */
   length: 1,
 
   /**
    * @see ActiveFilter.domainSeparator
@@ skipping 91 matching lines @@
 
 /**
  * Creates a RegExp filter from its text representation
  * @param {string} text   same as in Filter()
  * @return {Filter}
  */
 RegExpFilter.fromText = function(text)
 {
   let blocking = true;
   let origText = text;
-  if (text.indexOf("@@") == 0)
+  if (text[0] == "@" && text[1] == "@")
   {
     blocking = false;
     text = text.substr(2);
   }
 
   let contentType = null;
   let matchCase = null;
   let domains = null;
   let sitekeys = null;
   let thirdParty = null;
   let collapse = null;
   let csp = null;
   let rewrite = null;
   let options;
   let match = text.includes("$") ? Filter.optionsRegExp.exec(text) : null;
   if (match)
   {
     options = match[1].split(",");
     text = match.input.substr(0, match.index);
     for (let option of options)
     {
       let value = null;
       let separatorIndex = option.indexOf("=");
       if (separatorIndex >= 0)
       {
         value = option.substr(separatorIndex + 1);
         option = option.substr(0, separatorIndex);
       }
-      option = option.replace(/-/, "_").toUpperCase();
-      if (option in RegExpFilter.typeMap)
+
+      let inverse = option[0] == "~";
+      if (inverse)
+        option = option.substr(1);
+
+      let type = RegExpFilter.typeMap[option.replace(/-/, "_").toUpperCase()];
+      if (type)
       {
-        if (contentType == null)
-          contentType = 0;
-        contentType |= RegExpFilter.typeMap[option];
-
-        if (option == "CSP" && value)
-          csp = value;
+        if (inverse)
+        {
+          if (contentType == null)
+            ({contentType} = RegExpFilter.prototype);
+          contentType &= ~type;
+        }
+        else
+        {
+          contentType |= type;
+
+          if (type == RegExpFilter.typeMap.CSP && value)
+            csp = value;
+        }
       }
-      else if (option[0] == "~" && option.substr(1) in RegExpFilter.typeMap)
+      else
       {
-        if (contentType == null)
-          ({contentType} = RegExpFilter.prototype);
-        contentType &= ~RegExpFilter.typeMap[option.substr(1)];
+        switch (option.toLowerCase())
+        {
+          case "match-case":
+            matchCase = !inverse;
+            break;
+          case "domain":
+            if (!value)
+              return new InvalidFilter(origText, "filter_unknown_option");
+            domains = value.toLowerCase();
+            break;
+          case "third-party":
+            thirdParty = !inverse;
+            break;
+          case "collapse":
+            collapse = !inverse;
+            break;
+          case "sitekey":
+            if (!value)
+              return new InvalidFilter(origText, "filter_unknown_option");
+            sitekeys = value.toUpperCase();
+            break;
+          case "rewrite":
+            if (value == null)

[Manish Jethani, 2018/06/25 13:13:44]

Blank value is allowed for $rewrite here while still an error for $domain,
$sitekeys, and $csp.

[kzar, 2018/07/12 10:36:13]

So by checking for `value == null` instead of `!value` we'd allow "...$rewrite="
but not "rewrite$", or do I misunderstand? Either way, why don't you check for
`!value` here?

[Manish Jethani, 2018/07/12 10:52:55]

Yes, we're allowing $rewrite= but not $rewrite, because this is not a "flag"
like $match-case, it needs a value but it can take an empty value.

[kzar, 2018/07/12 11:04:20]

Ah right I see, we anticipate the confusion about adding the "=" for the users
who do want an empty value is less than the confusion of users who don't
understand the option at all and attempt to use it without a value.

[Manish Jethani, 2018/07/12 11:11:12]

Yup.

+              return new InvalidFilter(origText, "filter_unknown_option");
+            rewrite = value;
+            break;
+          default:
+            return new InvalidFilter(origText, "filter_unknown_option");
+        }
       }
-      else if (option == "MATCH_CASE")
-        matchCase = true;
-      else if (option == "~MATCH_CASE")
-        matchCase = false;
-      else if (option == "DOMAIN" && value != null)
-        domains = value.toUpperCase();
-      else if (option == "THIRD_PARTY")
-        thirdParty = true;
-      else if (option == "~THIRD_PARTY")
-        thirdParty = false;
-      else if (option == "COLLAPSE")
-        collapse = true;
-      else if (option == "~COLLAPSE")
-        collapse = false;
-      else if (option == "SITEKEY" && value != null)
-        sitekeys = value.toUpperCase();
-      else if (option == "REWRITE" && value != null)

[kzar, 2018/06/07 13:21:56]

Come to think of it, why don't we just allow the $rewrite option to be used
without the =? Then we don't have to mess with the regular expression or other
logic? I figure we could do something like this:

else if (option == "REWRITE")
  rewrite = value || "";

[Manish Jethani, 2018/06/25 13:13:44]

We could do that but it would be weird to allow $rewrite without a value but
still disallow blank values. What do you think? Anyway, this version of the
patch just allows `$rewrite=` but not just `$rewrite`.

-        rewrite = value;
-      else
-        return new InvalidFilter(origText, "filter_unknown_option");
     }
   }
 
   // For security reasons, never match $rewrite filters
   // against requests that might load any code to be executed.
   if (rewrite != null)
   {
     if (contentType == null)
       ({contentType} = RegExpFilter.prototype);
     contentType &= ~(RegExpFilter.typeMap.SCRIPT |
@@ skipping 55 matching lines @@
 // shouldn't be there by default
 RegExpFilter.prototype.contentType &= ~(RegExpFilter.typeMap.CSP |
                                         RegExpFilter.typeMap.DOCUMENT |
                                         RegExpFilter.typeMap.ELEMHIDE |
                                         RegExpFilter.typeMap.POPUP |
                                         RegExpFilter.typeMap.GENERICHIDE |
                                         RegExpFilter.typeMap.GENERICBLOCK);
 
 /**
  * Class for blocking filters
- * @param {string} text see Filter()
- * @param {string} regexpSource see RegExpFilter()
- * @param {number} [contentType] see RegExpFilter()
- * @param {boolean} [matchCase] see RegExpFilter()
- * @param {string} [domains] see RegExpFilter()
- * @param {boolean} [thirdParty] see RegExpFilter()
- * @param {string} [sitekeys] see RegExpFilter()
+ * @param {string} text see {@link Filter Filter()}
+ * @param {string} regexpSource see {@link RegExpFilter RegExpFilter()}
+ * @param {number} [contentType] see {@link RegExpFilter RegExpFilter()}
+ * @param {boolean} [matchCase] see {@link RegExpFilter RegExpFilter()}
+ * @param {string} [domains] see {@link RegExpFilter RegExpFilter()}
+ * @param {boolean} [thirdParty] see {@link RegExpFilter RegExpFilter()}
+ * @param {string} [sitekeys] see {@link RegExpFilter RegExpFilter()}
  * @param {boolean} [collapse]
  *   defines whether the filter should collapse blocked content, can be null
  * @param {string} [csp]
  *   Content Security Policy to inject when the filter matches
  * @param {?string} [rewrite]
  *   The (optional) rule specifying how to rewrite the URL. See
  *   BlockingFilter.prototype.rewrite.
  * @constructor
  * @augments RegExpFilter
  */
@@ skipping 53 matching lines @@
     catch (e)
     {
     }
 
     return url;
   }
 });
 
 /**
  * Class for whitelist filters
- * @param {string} text see Filter()
- * @param {string} regexpSource see RegExpFilter()
- * @param {number} [contentType] see RegExpFilter()
- * @param {boolean} [matchCase] see RegExpFilter()
- * @param {string} [domains] see RegExpFilter()
- * @param {boolean} [thirdParty] see RegExpFilter()
- * @param {string} [sitekeys] see RegExpFilter()
+ * @param {string} text see {@link Filter Filter()}
+ * @param {string} regexpSource see {@link RegExpFilter RegExpFilter()}
+ * @param {number} [contentType] see {@link RegExpFilter RegExpFilter()}
+ * @param {boolean} [matchCase] see {@link RegExpFilter RegExpFilter()}
+ * @param {string} [domains] see {@link RegExpFilter RegExpFilter()}
+ * @param {boolean} [thirdParty] see {@link RegExpFilter RegExpFilter()}
+ * @param {string} [sitekeys] see {@link RegExpFilter RegExpFilter()}
  * @constructor
  * @augments RegExpFilter
  */
 function WhitelistFilter(text, regexpSource, contentType, matchCase, domains,
                          thirdParty, sitekeys)
 {
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains,
                     thirdParty, sitekeys);
 }
 exports.WhitelistFilter = WhitelistFilter;
 
 WhitelistFilter.prototype = extend(RegExpFilter, {
   type: "whitelist"
 });
 
 /**
  * Base class for element hiding filters
- * @param {string} text see Filter()
+ * @param {string} text see {@link Filter Filter()}
  * @param {string} [domains] Host names or domains the filter should be
  *                           restricted to
  * @param {string} selector   CSS selector for the HTML elements that should be
  *                            hidden
  * @constructor
  * @augments ActiveFilter
  */
 function ElemHideBase(text, domains, selector)
 {
   ActiveFilter.call(this, text, domains || null);
@@ skipping 47 matching lines @@
       return new InvalidFilter(text, "filter_elemhideemulation_nodomain");
 
     return new ElemHideEmulationFilter(text, domains, selector);
   }
 
   return new ElemHideFilter(text, domains, selector);
 };
 
 /**
  * Class for element hiding filters
- * @param {string} text see Filter()
- * @param {string} [domains]  see ElemHideBase()
- * @param {string} selector see ElemHideBase()
+ * @param {string} text see {@link Filter Filter()}
+ * @param {string} [domains]  see {@link ElemHideBase ElemHideBase()}
+ * @param {string} selector see {@link ElemHideBase ElemHideBase()}
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideFilter(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideFilter = ElemHideFilter;
 
 ElemHideFilter.prototype = extend(ElemHideBase, {
   type: "elemhide"
 });
 
 /**
  * Class for element hiding exceptions
- * @param {string} text see Filter()
- * @param {string} [domains]  see ElemHideBase()
- * @param {string} selector see ElemHideBase()
+ * @param {string} text see {@link Filter Filter()}
+ * @param {string} [domains]  see {@link ElemHideBase ElemHideBase()}
+ * @param {string} selector see {@link ElemHideBase ElemHideBase()}
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideException(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideException = ElemHideException;
 
 ElemHideException.prototype = extend(ElemHideBase, {
   type: "elemhideexception"
 });
 
 /**
  * Class for element hiding emulation filters
- * @param {string} text           see Filter()
- * @param {string} domains        see ElemHideBase()
- * @param {string} selector       see ElemHideBase()
+ * @param {string} text           see {@link Filter Filter()}
+ * @param {string} domains        see {@link ElemHideBase ElemHideBase()}
+ * @param {string} selector       see {@link ElemHideBase ElemHideBase()}
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideEmulationFilter(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideEmulationFilter = ElemHideEmulationFilter;
 
 ElemHideEmulationFilter.prototype = extend(ElemHideBase, {
   type: "elemhideemulation"
 });