Issue 3222 - Expose filter type as a string property

lib/filterClasses.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 32 matching lines @@
    */
   text: null,
 
   /**
    * Filter subscriptions the filter belongs to
    * @type Subscription[]
    */
   subscriptions: null,
 
   /**
+   * Filter type as a string, e.g. "blocking".
+   * @type String
+   */
+  get type()
+  {
+    throw new Error("Please define filter type in the subclass");
+  },
+
+  /**
    * Serializes the filter to an array of strings for writing out on the disk.
    * @param {string[]} buffer  buffer to push the serialization results into
    */
   serialize: function(buffer)
   {
     buffer.push("[Filter]");
     buffer.push("text=" + this.text);
   },
 
   toString: function()
@@ skipping 136 matching lines @@
   Filter.call(this, text);
 
   this.reason = reason;
 }
 exports.InvalidFilter = InvalidFilter;
 
 InvalidFilter.prototype =
 {
   __proto__: Filter.prototype,
 
+  type: "invalid",
+
   /**
    * Reason why this filter is invalid
    * @type String
    */
   reason: null,
 
   /**
    * See Filter.serialize()
    */
   serialize: function(buffer) {}
 };
 
 /**
  * Class for comments
  * @param {String} text see Filter()
  * @constructor
  * @augments Filter
  */
 function CommentFilter(text)
 {
   Filter.call(this, text);
 }
 exports.CommentFilter = CommentFilter;
 
 CommentFilter.prototype =
 {
   __proto__: Filter.prototype,
 
+  type: "comment",
+
   /**
    * See Filter.serialize()
    */
   serialize: function(buffer) {}
 };
 
 /**
  * Abstract base class for filters that can get hits
  * @param {String} text see Filter()
  * @param {String} [domains] Domains that the filter is restricted to separated by domainSeparator e.g. "foo.com|bar.com|~baz.com"
@@ skipping 547 matching lines @@
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys);
 
   this.collapse = collapse;
 }
 exports.BlockingFilter = BlockingFilter;
 
 BlockingFilter.prototype =
 {
   __proto__: RegExpFilter.prototype,
 
+  type: "blocking",
+
   /**
    * Defines whether the filter should collapse blocked content. Can be null (use the global preference).
    * @type Boolean
    */
   collapse: null
 };
 
 /**
  * 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()
  * @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 =
 {
-  __proto__: RegExpFilter.prototype
+  __proto__: RegExpFilter.prototype,
+
+  type: "whitelist"
 };
 
 /**
  * Base class for element hiding filters
  * @param {String} text see 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
  */
@@ skipping 110 matching lines @@
  * @augments ElemHideBase
  */
 function ElemHideFilter(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideFilter = ElemHideFilter;
 
 ElemHideFilter.prototype =
 {
-  __proto__: ElemHideBase.prototype
+  __proto__: ElemHideBase.prototype,
+
+  type: "elemhide"
 };
 
 /**
  * Class for element hiding exceptions
  * @param {String} text see Filter()
  * @param {String} domains  see ElemHideBase()
  * @param {String} selector see ElemHideBase()
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideException(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideException = ElemHideException;
 
 ElemHideException.prototype =
 {
-  __proto__: ElemHideBase.prototype
+  __proto__: ElemHideBase.prototype,
+
+  type: "elemhideexception"
 };
 
 /**
  * Class for CSS property filters
  * @param {String} text           see Filter()
  * @param {String} domains        see ElemHideBase()
  * @param {String} selector       see ElemHideBase()
  * @param {String} regexpSource   see CSSPropertyFilter.regexpSource
  * @param {String} selectorPrefix see CSSPropertyFilter.selectorPrefix
  * @param {String} selectorSuffix see CSSPropertyFilter.selectorSuffix
  * @constructor
  * @augments ElemHideBase
  */
 function CSSPropertyFilter(text, domains, selector, regexpSource,
   selectorPrefix, selectorSuffix)
 {
   ElemHideBase.call(this, text, domains, selector);
 
   this.regexpSource = regexpSource;
   this.selectorPrefix = selectorPrefix;
   this.selectorSuffix = selectorSuffix;
 }
 exports.CSSPropertyFilter = CSSPropertyFilter;
 
 CSSPropertyFilter.prototype =
 {
   __proto__: ElemHideBase.prototype,
 
+  type: "cssproperty",
+
   /**
    * Expression from which a regular expression should be generated for matching
    * CSS properties - for delayed creation of the regexpString property
    * @type String
    */
   regexpSource: null,
   /**
    * Substring of CSS selector before properties for the HTML elements that
    * should be hidden
    * @type String
@@ skipping 17 matching lines @@
     // several times on Safari, due to WebKit bug 132872
     let prop = Object.getOwnPropertyDescriptor(this, "regexpString");
     if (prop)
       return prop.value;
 
     let regexp = Filter.toRegExp(this.regexpSource);
     Object.defineProperty(this, "regexpString", {value: regexp});
     return regexp;
   }
 };