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 =>

[Thomas Greiner, 2017/03/01 17:39:32]

Detail: Mind keeping the brackets? At least in Flattr Plus we agreed on using
brackets for single argument arrow functions for consistency.

[kzar, 2017/03/02 04:36:01]

I've opened a codereview to add the arrow-parens rule to our ESLint
configuration. Let's clear this up there once and for all
https://codereview.adblockplus.org/29377779/

[kzar, 2017/03/07 12:48:29]

As discussed we've decided against adding the arrow-parens rule globally. I'll
add it to the configuration here instead.

[Thomas Greiner, 2017/03/07 13:33:00]

I appreciate that because according to Felix it's up to the author to decide
whether or not to add parentheses or not.

+  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 */

[Thomas Greiner, 2017/03/01 17:39:32]

Detail: What about moving the constructors outside of the object definition
instead? The reasoning behind it being that it might not be wise to disable
rules for larger code blocks.

[kzar, 2017/03/07 12:48:29]

I think I've already done this when addressing Sebastian's feedback.

-  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
       }
     });
   });
-}
+}());