Issue 6034 - :-abp-contains() accept a regular expression

lib/content/elemHideEmulation.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 104 matching lines @@
     let priority = rule.style.getPropertyPriority(property);
     styles.push(`${property}: ${value}${priority ? " !" + priority : ""};`);
   }
   styles.sort();
   return {
     style: styles.join(" "),
     subSelectors: splitSelector(rule.selectorText)
   };
 }
 
+const regexpRegexp = /^\/(.*)\/([gimuy]*)$/;

[Manish Jethani, 2018/01/10 11:22:15]

We don't have to support all these flags, some of them don't make any sense
anyway.

g - no need, we only want one match anyway
i - OK
m - OK
u - no need, Unicode is supported in filters, i.e. you can use a Unicode
character directly instead of using sequences like "\u{1F47B}"
y - doesn't make sense for a filter

Also see:

https://github.com/gorhill/uBlock/issues/3372#issuecomment-354576078

[hub, 2018/01/10 18:27:22]

let's restrict to "im" for the flags.

+
+/**
+ * Make a regular expression from a text argument. If it can be parsed as a
+ * regular expression, parse it and the flags.
+ * @param {string} text the text argument.
+ * @param {?string} flag the regexp flag passed to the RegExp constructor:
+ * it overrides flags passed in the text argument.
+ * @return {RegExp} a RegExp object.
+ */
+function makeRegExpParameter(text, flag)

[Manish Jethani, 2018/01/10 11:22:14]

Shouldn't the parameter be called "flags" (plural)?

[hub, 2018/01/10 18:27:21]

Done.

+{
+  let regexpString = null;
+  let match = regexpRegexp.exec(text);
+  if (match)
+  {
+    regexpString = match[1].replace("\\7B ", "{").replace("\\7D ", "}");
+    if (!flag)

[Manish Jethani, 2018/01/10 11:22:15]

This changes the syntax of PropsSelector so that now it supports flags even
though the flags are ignored (always "i"). Instead we should just use two
separate regular expressions for ContainsSelector and PropsSelector.

[hub, 2018/01/10 18:27:22]

It is just more permissive to allow the regexp syntax with flags, which will be
ignored anyway. I don't think we need to make things more complex by having more
RegExp to parse.

+      flag = match[2];
+  }
+  else
+    regexpString = filterToRegExp(text);
+
+  return new RegExp(regexpString, flag);

[Manish Jethani, 2018/01/10 11:22:14]

We still need to handle the error if any.

[hub, 2018/01/10 18:27:21]

Done.

+}
+
 function* evaluate(chain, index, prefix, subtree, styles)
 {
   if (index >= chain.length)
   {
     yield prefix;
     return;
   }
   for (let [selector, element] of
        chain[index].getSelectors(prefix, subtree, styles))
   {
@@ skipping 82 matching lines @@
           // :scope isn't supported on Edge, ignore error caused by it.
         }
       }
       yield null;
     }
   }
 };
 
 function ContainsSelector(textContent)
 {
-  this._text = textContent;
+  this._regexp = makeRegExpParameter(textContent);
 }
 
 ContainsSelector.prototype = {
   requiresHiding: true,
 
   *getSelectors(prefix, subtree, stylesheet)
   {
     for (let element of this.getElements(prefix, subtree, stylesheet))
       yield [makeSelector(element, ""), subtree];
   },
 
   *getElements(prefix, subtree, stylesheet)
   {
     let actualPrefix = (!prefix || incompletePrefixRegexp.test(prefix)) ?
         prefix + "*" : prefix;
     let elements = subtree.querySelectorAll(actualPrefix);
 
     for (let element of elements)
     {
-      if (element.textContent.includes(this._text))
+      if (this._regexp && this._regexp.test(element.textContent))
         yield element;
       else
         yield null;

[lainverse, 2018/01/10 09:14:02]

BTW, while we are at it why do we even want to yield null? As I understand
makeSelector will skip it anyway. Similar yield in the other getElements
function.

[lainverse, 2018/01/10 19:10:22]

Checked. makeSelectors returns null if null is passed as selector (and that's
what getSelectors does), then getSelectors yields an array [null, subtree],
"evaluate" yields null when encounters null there later on and processPatterns
skips all null selectors because what else could it do with them anyway? I can
make an assumption that on some sites it leads to hundreds of useless calls just
to do one or two right.

     }
   }
 };
 
 function PropsSelector(propertyExpression)
 {
-  let regexpString;
-  if (propertyExpression.length >= 2 && propertyExpression[0] == "/" &&
-      propertyExpression[propertyExpression.length - 1] == "/")
-  {
-    regexpString = propertyExpression.slice(1, -1)
-      .replace("\\7B ", "{").replace("\\7D ", "}");
-  }
-  else
-    regexpString = filterToRegExp(propertyExpression);
-
-  this._regexp = new RegExp(regexpString, "i");
+  this._regexp = makeRegExpParameter(propertyExpression, "i");
 }
 
 PropsSelector.prototype = {
   preferHideWithSelector: true,
   dependsOnStyles: true,
 
   *findPropsSelectors(styles, prefix, regexp)
   {
     for (let style of styles)
       if (regexp.test(style.style))
@@ skipping 326 matching lines @@
           characterData: true,
           subtree: true
         }
       );
       this.document.addEventListener("load", this.onLoad.bind(this), true);
     }
   }
 };
 
 exports.ElemHideEmulation = ElemHideEmulation;