Issue 5761 - Changes require paths to relative

background.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 15 matching lines @@
   EventEmitter.prototype = {
     on(name, listener)
     {
       if (name in this._listeners)
         this._listeners[name].push(listener);
       else
         this._listeners[name] = [listener];
     },
     off(name, listener)
     {
-      let listeners = this._listeners[name];
+      const listeners = this._listeners[name];
       if (listeners)
       {
-        let idx = listeners.indexOf(listener);
+        const idx = listeners.indexOf(listener);
         if (idx != -1)
           listeners.splice(idx, 1);
       }
     },
     emit(name, ...args)
     {
-      let listeners = this._listeners[name];
+      const listeners = this._listeners[name];
       if (listeners)
       {
-        for (let listener of listeners)
+        for (const listener of listeners)
           listener(...args);
       }
     }
   };
 
   function updateFromURL(data)
   {
     if (window.location.search)
     {
-      let params = window.location.search.substr(1).split("&");
-
-      for (let param of params)
-      {
-        let parts = param.split("=", 2);
+      const params = window.location.search.substr(1).split("&");
+
+      for (const param of params)
+      {
+        const parts = param.split("=", 2);
         if (parts.length == 2 && parts[0] in data)
           data[parts[0]] = decodeURIComponent(parts[1]);
       }
     }
   }
 
-  let params = {
+  const params = {
     additionalSubscriptions: "",
     blockedURLs: "",
     dataCorrupted: false,
     filterlistsReinitialized: false,
     addSubscription: false,
     filterError: false,
     downloadStatus: "synchronize_ok",
     showNotificationUI: false,
     showPageOptions: false
   };
   updateFromURL(params);
 
   const subscriptionServer = "https://easylist-downloads.adblockplus.org";
   const easyListGermany = `${subscriptionServer}/easylistgermany+easylist.txt`;
   const acceptableAds = `${subscriptionServer}/exceptionrules.txt`;
   const acceptableAdsPrivacyFriendly =
     `${subscriptionServer}/exceptionrules-privacy-friendly.txt`;
   const redirectLink = "https://adblockplus.org/redirect?link=";
 
-  let modules = {};
+  const modules = {};
   window.require = function(module)
   {
-    return modules[module.substr(module.lastIndexOf("/") + 1)];

[a.giammarchi, 2018/07/02 08:14:26]

this is probably already fine but assumes there is a `/` in the path.

What always works and produces same result instead is `module.split('/').pop()`,
so that even if there's no slash in the path, you'll have a module to load (i.e.
the "info" one, whenever it gets involved in here).

Feel free to ignore this comment if there won't ever be a case without a slash.

[Jon Sonesen, 2018/07/09 19:23:49]

Yeah, previously there were never `/` characters but now i think they will
always appear (perhaps the info module is the exception here) Thomas, Dave what
do you think?

[Thomas Greiner, 2018/07/26 10:07:59]

I'd say let's go with whichever requires making fewer assumptions. So in this
case that would be `module.split("/").pop()`.

+    return modules[module.split("/").pop()];
   };
 
   modules.utils = {
     Utils: {
       getDocLink(link)
       {
         return `${redirectLink}${encodeURIComponent(link)}`;
       },
       get appLocale()
       {
         return browser.i18n.getUILanguage();
       },
       get readingDirection()
       {
         return /^(?:ar|fa|he|ug|ur)\b/.test(this.appLocale) ? "rtl" : "ltr";
       }
     }
   };
 
   modules.prefs = {Prefs: new EventEmitter()};
-  let prefs = {
+  const prefs = {
     notifications_ignoredcategories: params.showNotificationUI ? ["*"] : [],
     notifications_showui: params.showNotificationUI,
     shouldShowBlockElementMenu: true,
     show_devtools_panel: true,
     ui_warn_tracking: true,
     additional_subscriptions: params.additionalSubscriptions.split(","),
     subscriptions_exceptionsurl: acceptableAds,
     subscriptions_exceptionsurl_privacy: acceptableAdsPrivacyFriendly
   };
-  for (let key of Object.keys(prefs))
+  for (const key of Object.keys(prefs))
   {
     Object.defineProperty(modules.prefs.Prefs, key, {
       get()
       {
         return prefs[key];
       },
       set(value)
       {
         prefs[key] = value;
         modules.prefs.Prefs.emit(key);
       }
     });
   }
 
   modules.notification = {
     Notification: {
       toggleIgnoreCategory(category)
       {
-        let categories = prefs.notifications_ignoredcategories;
-        let index = categories.indexOf(category);
+        const categories = prefs.notifications_ignoredcategories;
+        const index = categories.indexOf(category);
         if (index == -1)
           categories.push(category);
         else
           categories.splice(index, 1);
         modules.prefs.Prefs.notifications_ignoredcategories = categories;
       }
     }
   };
 
   modules.notificationHelper = {
     getActiveNotification()
     {
     },
     shouldDisplay()
     {
       return true;
     }
   };
 
-  let subscriptionDetails = {
+  const subscriptionDetails = {
     [easyListGermany]: {
       title: "EasyList Germany+EasyList",
       filters: ["-ad-banner.", "-ad-big.", "-ad-bottom-", "-ad-button-"],
       installed: true
     },
     [acceptableAds]: {
       title: "Allow non-intrusive advertising",
       installed: true
     },
     [acceptableAdsPrivacyFriendly]: {
       title: "Allow only nonintrusive ads that are privacy-friendly"
     },
     [`${subscriptionServer}/fanboy-social.txt`]: {
       title: "Fanboy's Social Blocking List",
       installed: true
+    },
+    [`${subscriptionServer}/abp-filters-anti-cv.txt`]: {
+      title: "ABP Anti-Circumvention list",
+      installed: true,
+      disabled: false,
+      recommended: "circumvention"
     },
     [`${subscriptionServer}/antiadblockfilters.txt`]: {
       title: "Adblock Warning Removal List",
       installed: true,
       disabled: true
     },
     "~user~786254": {
       installed: true
     }
   };
 
   function Subscription(url)
   {
     this.url = url;
     this._disabled = false;
     this._lastDownload = 1234;
     this.filters = [];
     this.homepage = "https://easylist.adblockplus.org/";
     this.downloadStatus = params.downloadStatus;
 
-    let details = subscriptionDetails[this.url];
+    const details = subscriptionDetails[this.url];
     if (details)
     {
       this.disabled = !!details.disabled;
       this.title = details.title || "";
       this.filters = this.filters.concat(details.filters);
     }
   }
   Subscription.prototype =
   {
     get disabled()
@@ skipping 11 matching lines @@
     },
     set lastDownload(value)
     {
       this._lastDownload = value;
       modules.filterNotifier.FilterNotifier.emit("subscription.lastDownload",
         this);
     }
   };
   Subscription.fromURL = function(url)
   {
-    if (url in knownSubscriptions)
-      return knownSubscriptions[url];
+    if (knownSubscriptions.has(url))
+      return knownSubscriptions.get(url);
 
     if (/^https?:\/\//.test(url))
       return new modules.subscriptionClasses.Subscription(url);
     return new modules.subscriptionClasses.SpecialSubscription(url);
   };
 
   function SpecialSubscription(url)
   {
     this.url = url;
     this.disabled = false;
     this.filters = knownFilters.slice();
   }
 
   modules.subscriptionClasses = {
     Subscription,
     SpecialSubscription,
     DownloadableSubscription: Subscription
   };
 
   modules.filterStorage = {
     FilterStorage: {
       get subscriptions()
       {
-        let subscriptions = [];
-        for (let url in modules.filterStorage.FilterStorage.knownSubscriptions)
+        return Array.from(knownSubscriptions.values());
+      },
+
+      get knownSubscriptions()
+      {
+        return knownSubscriptions;
+      },
+
+      addSubscription(subscription)
+      {
+        const {fromURL} = Subscription;
+
+        if (!knownSubscriptions.has(subscription.url))
         {
-          subscriptions.push(
-            modules.filterStorage.FilterStorage.knownSubscriptions[url]
-          );
-        }
-        return subscriptions;
-      },
-
-      get knownSubscriptions()
-      {
-        return knownSubscriptions;
-      },
-
-      addSubscription(subscription)
-      {
-        let {fromURL} = Subscription;
-        let {FilterStorage} = modules.filterStorage;
-
-        if (!(subscription.url in FilterStorage.knownSubscriptions))
-        {
-          knownSubscriptions[subscription.url] = fromURL(subscription.url);
+          knownSubscriptions.set(subscription.url, fromURL(subscription.url));
           modules.filterNotifier.FilterNotifier.emit("subscription.added",
             subscription);
         }
       },
 
       removeSubscription(subscription)
       {
-        let {FilterStorage} = modules.filterStorage;
-
-        if (subscription.url in FilterStorage.knownSubscriptions)
+        if (knownSubscriptions.has(subscription.url))
         {
-          delete knownSubscriptions[subscription.url];
+          knownSubscriptions.delete(subscription.url);
           modules.filterNotifier.FilterNotifier.emit("subscription.removed",
             subscription);
         }
       },
 
       addFilter(filter)
       {
-        for (let customFilter of customSubscription.filters)
+        for (const customFilter of customSubscription.filters)
         {
           if (customFilter.text == filter.text)
             return;
         }
         customSubscription.filters.push(filter);
         modules.filterNotifier.FilterNotifier.emit("filter.added", filter);
       },
 
       removeFilter(filter)
       {
@@ skipping 78 matching lines @@
       {
         return modules.synchronizer.Synchronizer._downloading;
       }
     }
   };
 
   modules.matcher = {
     defaultMatcher: {
       matchesAny(url, requestType, docDomain, thirdParty)
       {
-        let blocked = params.blockedURLs.split(",");
+        const blocked = params.blockedURLs.split(",");
         if (blocked.indexOf(url) >= 0)
           return new modules.filterClasses.BlockingFilter();
         return null;
       }
     }
   };
 
   modules.filterNotifier = {
     FilterNotifier: new EventEmitter()
   };
@@ skipping 25 matching lines @@
 
       if (callback)
         callback();
     }
   };
 
   window.addEventListener("message", (event) =>
   {
     if (event.data.type != "message")
       return;
-    let message = event.data.payload;
-    let {messageId} = event.data;
-    let sender = {
+    const message = event.data.payload;
+    const {messageId} = event.data;
+    const sender = {
       page: new ext.Page(event.source)
     };
 
-    let listeners = modules.messaging.port._listeners[message.type];
+    const listeners = modules.messaging.port._listeners[message.type];
     if (!listeners)
       return;
 
     function reply(responseMessage)
     {
       event.source.postMessage({
         type: "response",
         messageId,
         payload: responseMessage
       }, "*");
     }
 
-    for (let listener of listeners)
-    {
-      let response = listener(message, sender);
+    for (const listener of listeners)
+    {
+      const response = listener(message, sender);
       if (response && typeof response.then == "function")
       {
         response.then(
           reply,
           (reason) =>
           {
             console.error(reason);
             reply(undefined);
           }
         );
       }
       else if (typeof response != "undefined")
       {
         reply(response);
       }
     }
   });
 
-  let filters = [
+  const filters = [
     "@@||alternate.de^$document",
     "@@||der.postillion.com^$document",
     "@@||taz.de^$document",
     "@@||amazon.de^$document",
     "||biglemon.am/bg_poster/banner.jpg",
     "winfuture.de###header_logo_link",
     "###WerbungObenRechts10_GesamtDIV",
     "###WerbungObenRechts8_GesamtDIV",
     "###WerbungObenRechts9_GesamtDIV",
     "###WerbungUntenLinks4_GesamtDIV",
     "###WerbungUntenLinks7_GesamtDIV",
     "###WerbungUntenLinks8_GesamtDIV",
     "###WerbungUntenLinks9_GesamtDIV",
     "###Werbung_Sky",
     "###Werbung_Wide",
     "###__ligatus_placeholder__",
     "###ad-bereich1-08",
     "###ad-bereich1-superbanner",
     "###ad-bereich2-08",
     "###ad-bereich2-skyscrapper"
   ];
-  let knownFilters = filters.map(modules.filterClasses.Filter.fromText);
-
-  let knownSubscriptions = Object.create(null);
-  for (let url in subscriptionDetails)
+  const knownFilters = filters.map(modules.filterClasses.Filter.fromText);
+
+  const knownSubscriptions = new Map();
+  for (const url in subscriptionDetails)
   {
     if (!subscriptionDetails[url].installed)
       continue;
 
-    knownSubscriptions[url] =
-      modules.subscriptionClasses.Subscription.fromURL(url);
-  }
-  let customSubscription = knownSubscriptions["~user~786254"];
+    knownSubscriptions.set(
+      url,
+      modules.subscriptionClasses.Subscription.fromURL(url)
+    );
+  }
+  const customSubscription = knownSubscriptions.get("~user~786254");
 
   if (params.addSubscription)
   {
     // We don't know how long it will take for the page to fully load
     // so we'll post the message after one second
     setTimeout(() =>
     {
       window.postMessage({
         type: "message",
         payload: {
           title: "Custom subscription",
           url: "http://example.com/custom.txt",
           confirm: true,
           type: "subscriptions.add"
         }
       }, "*");
     }, 1000);
   }
 
   if (params.showPageOptions)
   {
     // We don't know how long it will take for the page to fully load
     // so we'll post the message after one second
     setTimeout(() =>
     {
-      let host = "example.com";
-      let isWhitelisted = customSubscription.filters
+      const host = "example.com";
+      const isWhitelisted = customSubscription.filters
         .some((filter) => filter.text == `@@||${host}^$document`);
       window.postMessage({
         type: "message",
         payload: {
           type: "app.open",
           what: "options",
           action: "showPageOptions",
           args: [
             {
               host,
@@ skipping 73 matching lines @@
         type: "POPUP",
         docDomain: "example.com"
       },
       filter: {
         text: "||example.com/some-annoying-popup$popup",
         whitelisted: false,
         userDefined: true,
         subscription: null
       }
     });
+
+    // rewrite
+    panel.sendMessage({
+      type: "add-record",
+      request: {
+        url: "http://example.com/some-annoying-popup",
+        type: "OTHER",
+        docDomain: "example.com",
+        rewrittenUrl: "http://example.com/some-annoying-popup?nopopup"
+      },
+      filter: {
+        text: "/(example\\.com\\/some-annoying-popup\\)$/$rewrite=$1?nopopup",
+        whitelisted: false,
+        userDefined: true,
+        subscription: null
+      }
+    });
   });
 }());