Issue 6940 - Use underscore prefixes lib/matcher.js

lib/matcher.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 23 matching lines @@
     /**
      * Lookup table for filters by their associated keyword
      * @type {Map.<string,(Filter|Filter[])>}
      */
     this.filterByKeyword = new Map();
 
     /**
      * Lookup table for keywords by the filter
      * @type {Map.<Filter,string>}
      */
-    this.keywordByFilter = new Map();
+    this._keywordByFilter = new Map();

[Manish Jethani, 2018/10/01 15:08:59]

I think we should add the `@private` tag here.

Other than this, the change looks good to me, but let's wait for the rebase.

[Manish Jethani, 2018/10/01 15:10:00]

I'm wondering where exactly it should be added. I guess let's make it a practice
of adding it last (after `@type` here).

[Jon Sonesen, 2018/10/21 03:07:07]

Done.

   }
 
   /**
    * Removes all known filters
    */
   clear()
   {
     this.filterByKeyword.clear();
-    this.keywordByFilter.clear();
+    this._keywordByFilter.clear();
   }
 
   /**
    * Adds a filter to the matcher
    * @param {RegExpFilter} filter
    */
   add(filter)
   {
-    if (this.keywordByFilter.has(filter))
+    if (this._keywordByFilter.has(filter))
       return;
 
     // Look for a suitable keyword
     let keyword = this.findKeyword(filter);
     let oldEntry = this.filterByKeyword.get(keyword);
     if (typeof oldEntry == "undefined")
       this.filterByKeyword.set(keyword, filter);
     else if (oldEntry.length == 1)
       this.filterByKeyword.set(keyword, [oldEntry, filter]);
     else
       oldEntry.push(filter);
-    this.keywordByFilter.set(filter, keyword);
+    this._keywordByFilter.set(filter, keyword);
   }
 
   /**
    * Removes a filter from the matcher
    * @param {RegExpFilter} filter
    */
   remove(filter)
   {
-    let keyword = this.keywordByFilter.get(filter);
+    let keyword = this._keywordByFilter.get(filter);
     if (typeof keyword == "undefined")
       return;
 
     let list = this.filterByKeyword.get(keyword);
     if (list.length <= 1)
       this.filterByKeyword.delete(keyword);
     else
     {
       let index = list.indexOf(filter);
       if (index >= 0)
       {
         list.splice(index, 1);
         if (list.length == 1)
           this.filterByKeyword.set(keyword, list[0]);
       }
     }
 
-    this.keywordByFilter.delete(filter);
+    this._keywordByFilter.delete(filter);
   }
 
   /**
    * Chooses a keyword to be associated with the filter
    * @param {Filter} filter
    * @returns {string} keyword or an empty string if no keyword could be found
    */
   findKeyword(filter)
   {
     let result = "";
@@ skipping 26 matching lines @@
     return result;
   }
 
   /**
    * Checks whether a particular filter is being matched against.
    * @param {RegExpFilter} filter
    * @returns {boolean}
    */
   hasFilter(filter)
   {
-    return this.keywordByFilter.has(filter);
+    return this._keywordByFilter.has(filter);
   }
 
   /**
    * Returns the keyword used for a filter, <code>null</code>
    * for unknown filters.
    * @param {RegExpFilter} filter
    * @returns {?string}
    */
   getKeywordForFilter(filter)
   {
-    let keyword = this.keywordByFilter.get(filter);
+    let keyword = this._keywordByFilter.get(filter);
     return typeof keyword != "undefined" ? keyword : null;
   }
 
   /**
    * Checks whether the entries for a particular keyword match a URL
    * @param {string} keyword
    * @param {string} location
    * @param {number} typeMask
    * @param {string} [docDomain]
    * @param {boolean} [thirdParty]
@@ skipping 244 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;