Issue 4329 - Add $genericblock support

lib/abp2blocklist.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 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 196 matching lines @@
                             typeMap.OBJECT_SUBREQUEST |
                             typeMap.PING |
                             typeMap.OTHER))
     types.push("raw");
   if (filter.contentType & typeMap.SUBDOCUMENT)
     types.push("document");
 
   return types;
 }
 
-function convertFilterAddRules(rules, filter, action, withResourceTypes)
+function convertFilterAddRules(rules, filter, action, withResourceTypes,
+                               exceptionDomains)
 {
   let parsed = parseFilterRegexpSource(filter.regexpSource);
 
   // For the special case of $document whitelisting filters with just a domain
   // we can generate an equivalent blocking rule exception using if-domain.
   if (filter instanceof filterClasses.WhitelistFilter &&
       filter.contentType & typeMap.DOCUMENT &&
       parsed.justHostname)
   {
     rules.push({
@@ skipping 17 matching lines @@
 
   // For rules containing only a hostname we know that we're matching against
   // a lowercase string unless the matchCase option was passed.
   if (parsed.canSafelyMatchAsLowercase && !filter.matchCase)
     trigger["url-filter"] = trigger["url-filter"].toLowerCase();
 
   if (parsed.canSafelyMatchAsLowercase || filter.matchCase)
     trigger["url-filter-is-case-sensitive"] = true;
 
   let included = [];
-  let excluded = [];
+  let excluded = exceptionDomains && exceptionDomains.slice() || [];

[Sebastian Noack, 2017/05/20 06:25:28]

Nit: The ternary operator seems more appropriate here.

[Manish Jethani, 2017/05/20 19:30:22]

Actually now that I think of it, the $genericblock domains should be added after
the filter-specific exception domains. I've updated this now.

 
   parseDomains(filter.domains, included, excluded);
 
   if (withResourceTypes)
   {
     trigger["resource-type"] = getResourceTypes(filter);
 
     if (trigger["resource-type"].length == 0)
       return;
   }
@@ skipping 89 matching lines @@
  * Create a new Adblock Plus filter to content blocker list converter
  *
  * @constructor
  */
 exports.ContentBlockerList = function ()
 {
   this.requestFilters = [];
   this.requestExceptions = [];
   this.elemhideFilters = [];
   this.elemhideExceptions =  [];
+  this.genericblockExceptions = [];
   this.elemhideSelectorExceptions = new Map();
 };
 
 /**
  * Add Adblock Plus filter to be converted
  *
  * @param {Filter} filter Filter to convert
  */
 ContentBlockerList.prototype.addFilter = function(filter)
 {
   if (filter.sitekeys)
     return;
   if (filter instanceof filterClasses.RegExpFilter &&
       filter.regexpSource == null)
     return;
 
   if (filter instanceof filterClasses.BlockingFilter)
     this.requestFilters.push(filter);
 
   if (filter instanceof filterClasses.WhitelistFilter)
   {
     if (filter.contentType & (typeMap.DOCUMENT | whitelistableRequestTypes))
       this.requestExceptions.push(filter);
 
       if (filter.contentType & typeMap.ELEMHIDE)
         this.elemhideExceptions.push(filter);
+
+    if (filter.contentType & typeMap.GENERICBLOCK)
+      this.genericblockExceptions.push(filter);
   }
 
   if (filter instanceof filterClasses.ElemHideFilter)
     this.elemhideFilters.push(filter);
 
   if (filter instanceof filterClasses.ElemHideException)
   {
     let domains = this.elemhideSelectorExceptions[filter.selector];
     if (!domains)
       domains = this.elemhideSelectorExceptions[filter.selector] = [];
@@ skipping 43 matching lines @@
         trigger: {"url-filter": matchDomain,
                   "url-filter-is-case-sensitive": true},
         action: {type: "css-display-none",
                  selector: selector}
       });
     }
   });
 
   for (let filter of this.elemhideExceptions)
     convertFilterAddRules(rules, filter, "ignore-previous-rules", false);
+
+  let requestFilterExceptionDomains = [];
+  for (let filter of this.genericblockExceptions)
+  {
+    let parsed = parseFilterRegexpSource(filter.regexpSource);
+    if (parsed.hostname)
+      requestFilterExceptionDomains.push(parsed.hostname);
+  }
+
   for (let filter of this.requestFilters)
-    convertFilterAddRules(rules, filter, "block", true);
+  {
+    convertFilterAddRules(rules, filter, "block", true,
+                          requestFilterExceptionDomains);
+  }
+
   for (let filter of this.requestExceptions)
     convertFilterAddRules(rules, filter, "ignore-previous-rules", true);
 
   return rules.filter(rule => !hasNonASCI(rule));
 };