Issue 4871 - Start using ESLint for adblockplusui

background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
+(function()
 {
   function EventEmitter()
   {
     this._listeners = Object.create(null);
   }
   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];
       if (listeners)
       {
         let idx = listeners.indexOf(listener);
         if (idx != -1)
           listeners.splice(idx, 1);
       }
     },
     emit(name, ...args)
     {
       let listeners = this._listeners[name];
       if (listeners)
       {
-        for (let i = 0; i < listeners.length; i++)
-          listeners[i](...args);
+        for (let listener of listeners)
+          listener(...args);
       }
     }
   };
 
   function updateFromURL(data)
   {
     if (window.location.search)
     {
       let params = window.location.search.substr(1).split("&");
-      for (let i = 0; i < params.length; i++)
-      {
-        let parts = params[i].split("=", 2);
+
+      for (let param of params)
+      {
+        let parts = param.split("=", 2);
         if (parts.length == 2 && parts[0] in data)
           data[parts[0]] = decodeURIComponent(parts[1]);
       }
     }
   }
 
   let params = {
     blockedURLs: "",
     filterlistsReinitialized: false,
     addSubscription: false,
@@ skipping 23 matching lines @@
   };
 
   modules.prefs = {Prefs: new EventEmitter()};
   let prefs = {
     notifications_ignoredcategories: (params.showNotificationUI) ? ["*"] : [],
     notifications_showui: params.showNotificationUI,
     shouldShowBlockElementMenu: true,
     show_devtools_panel: true,
     subscriptions_exceptionsurl: "https://easylist-downloads.adblockplus.org/exceptionrules.txt"
   };
-  Object.keys(prefs).forEach(key =>
+  for (let 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);
         if (index == -1)
           categories.push(category);
         else
           categories.splice(index, 1);
         modules.prefs.Prefs.notifications_ignoredcategories = categories;
       }
     }
   };
 
-  /* eslint-disable object-shorthand */

[Sebastian Noack, 2017/02/21 12:21:20]

Note that the object-shorthand rule has an ignoreConstructors option, in order
to ignore capitalized properties.

Alternatively, we could just define the constructur beforehand, as we did in at
least one other place already, in order to avoid triggering this rule:

  function Subscription()
  {
    ...
  }
  modules.subscriptionClasses = {
    Subscription,
    ...
  };

Not sure which I prefer. But either option seems better than the inline
configuration.

[kzar, 2017/02/23 11:10:22]

Done.

-  modules.subscriptionClasses = {
-    Subscription: function(url)
-    {
-      this.url = url;
-      this._disabled = false;
-      this._lastDownload = 1234;
-      this.homepage = "https://easylist.adblockplus.org/";
-      this.downloadStatus = params.downloadStatus;
-    },
-
-    SpecialSubscription: function(url)
-    {
-      this.url = url;
-      this.disabled = false;
-      this.filters = knownFilters.slice();
-    }
-  };
-  modules.subscriptionClasses.Subscription.fromURL = function(url)
-  {
-    if (url in knownSubscriptions)
-      return knownSubscriptions[url];
-
-    if (/^https?:\/\//.test(url))
-      return new modules.subscriptionClasses.Subscription(url);
-    return new modules.subscriptionClasses.SpecialSubscription(url);
-  };
-  /* eslint-enable object-shorthand */
-  modules.subscriptionClasses.DownloadableSubscription =
-    modules.subscriptionClasses.Subscription;
-
-  modules.subscriptionClasses.Subscription.prototype =
+  function Subscription(url)
+  {
+    this.url = url;
+    this._disabled = false;
+    this._lastDownload = 1234;
+    this.homepage = "https://easylist.adblockplus.org/";
+    this.downloadStatus = params.downloadStatus;
+  }
+  Subscription.prototype =
   {
     get disabled()
     {
       return this._disabled;
     },
     set disabled(value)
     {
       this._disabled = value;
       modules.filterNotifier.FilterNotifier.emit("subscription.disabled", this);
     },
     get lastDownload()
     {
       return this._lastDownload;
     },
     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 (/^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)
         {
           subscriptions.push(
             modules.filterStorage.FilterStorage.knownSubscriptions[url]
           );
         }
         return subscriptions;
       },
 
       get knownSubscriptions()
       {
         return knownSubscriptions;
       },
 
       addSubscription(subscription)
       {
-        let {fromURL} = modules.subscriptionClasses.Subscription;
+        let {fromURL} = Subscription;
         let {FilterStorage} = modules.filterStorage;
 
         if (!(subscription.url in FilterStorage.knownSubscriptions))
         {
           knownSubscriptions[subscription.url] = fromURL(subscription.url);
           modules.filterNotifier.FilterNotifier.emit("subscription.added",
                                                      subscription);
         }
       },
 
       removeSubscription(subscription)
       {
         let {FilterStorage} = modules.filterStorage;
 
         if (subscription.url in FilterStorage.knownSubscriptions)
         {
           delete knownSubscriptions[subscription.url];
           modules.filterNotifier.FilterNotifier.emit("subscription.removed",
                                                      subscription);
         }
       },
 
       addFilter(filter)
       {
-        for (let i = 0; i < customSubscription.filters.length; i++)
+        for (let customFilter of customSubscription.filters)
         {
-          if (customSubscription.filters[i].text == filter.text)
+          if (customFilter.text == filter.text)
             return;
         }
         customSubscription.filters.push(filter);
         modules.filterNotifier.FilterNotifier.emit("filter.added", filter);
       },
 
       removeFilter(filter)
       {
         for (let i = 0; i < customSubscription.filters.length; i++)
         {
           if (customSubscription.filters[i].text == filter.text)
           {
             customSubscription.filters.splice(i, 1);
             modules.filterNotifier.FilterNotifier.emit("filter.removed",
                                                        filter);
             return;
           }
         }
       }
     }
   };
 
-  /* eslint-disable object-shorthand */
+  function Filter(text)
+  {
+    this.text = text;
+    this.disabled = false;
+  }
+  Filter.fromText = (text) => new Filter(text);
+
+  function BlockingFilter()
+  {
+  }
+
+  function RegExpFilter()
+  {
+  }
+  RegExpFilter.typeMap = Object.create(null);
+
   modules.filterClasses = {
-    BlockingFilter: () => {},
-    Filter: function(text)
-    {
-      this.text = text;
-      this.disabled = false;
-    },
-    RegExpFilter: () => {}
-  };
-  /* eslint-enable object-shorthand */
-  modules.filterClasses.Filter.fromText = function(text)
-  {
-    return new modules.filterClasses.Filter(text);
-  };
-  modules.filterClasses.RegExpFilter.typeMap = Object.create(null);
+    BlockingFilter,
+    Filter,
+    RegExpFilter
+  };
 
   modules.filterValidation =
   {
     parseFilter(text)
     {
       if (params.filterError)
         return {error: "Invalid filter"};
       return {filter: modules.filterClasses.Filter.fromText(text)};
     },
     parseFilters(text)
     {
       if (params.filterError)
         return {errors: ["Invalid filter"]};
       return {
         filters: text.split("\n")
-          .filter(filter => !!filter)
+          .filter((filter) => !!filter)
           .map(modules.filterClasses.Filter.fromText),
         errors: []
       };
     }
   };
 
   modules.synchronizer = {
     Synchronizer: {
       _downloading: false,
       execute(subscription, manual)
@@ skipping 46 matching lines @@
   updateFromURL(modules.info);
 
   modules.subscriptionInit = {
     reinitialized: params.filterlistsReinitialized
   };
 
   modules.messaging = {
     port: new EventEmitter()
   };
 
-  window.addEventListener("message", event =>
+  window.addEventListener("message", (event) =>
   {
     if (event.data.type != "message")
       return;
     let message = event.data.payload;
     let {messageId} = event.data;
     let sender = {
       page: new ext.Page(event.source)
     };
 
     let 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);
       if (response && typeof response.then == "function")
       {
         response.then(
           reply,
-          reason =>
+          (reason) =>
           {
             console.error(reason);
             reply(undefined);
           }
         );
       }
       else if (typeof response != "undefined")
+      {
         reply(response);
+      }
     }
   });
 
   window.Services = {
     vc: {
       compare(v1, v2)
       {
         return parseFloat(v1) - parseFloat(v2);
       }
     }
@@ skipping 48 matching lines @@
         payload: {
           title: "Custom subscription",
           url: "http://example.com/custom.txt",
           confirm: true,
           type: "subscriptions.add"
         }
       }, "*");
     }, 1000);
   }
 
-  ext.devtools.onCreated.addListener(panel =>
+  ext.devtools.onCreated.addListener((panel) =>
   {
     // blocked request
     panel.sendMessage({
       type: "add-record",
       request: {
         url: "http://adserver.example.com/ad_banner.png",
         type: "IMAGE",
         docDomain: "example.com"
       },
       filter: {
@@ skipping 55 matching lines @@
         docDomain: "example.com"
       },
       filter: {
         text: "||example.com/some-annoying-popup$popup",
         whitelisted: false,
         userDefined: true,
         subscription: null
       }
     });
   });
-}
+}());