Issue 5157 - Update dependency on adblockpluscore to revision 66bcf4dca35a

lib/io.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 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 37 matching lines @@
   {
     return new Promise((resolve, reject) =>
     {
       let id = ++messageID;
       messageCallbacks.set(id, {resolve, reject});
       port.postMessage({id, method, args});
     });
   });
 }
 
-function attachCallback(promise, callback, fallback)
+function callLegacy(method, ...args)
 {
-  promise.then(result =>
+  return new Promise((resolve, reject) =>
   {
-    callback(null, result);
-  }).catch(error =>
-  {
-    if (fallback && error == "NoSuchFile")
-      fallback();
-    else
-      callback(error);
+    LegacyIO[method](...args, (error, result) =>
+    {
+      if (error)
+        reject(error);
+      else
+        resolve(result);
+    });
   });
 }
 
+function legacyFile(fileName)
+{
+  let file = LegacyIO.resolveFilePath("adblockplus");
+  file.append(fileName);
+  return file;
+}
+
 exports.IO =
 {
-  resolveFilePath: LegacyIO.resolveFilePath,
+  /**
+   * @callback TextSink
+   * @param {string} line
+   */
 
   /**
-   * Reads strings from a file asynchronously, calls listener.process() with
-   * each line read and with a null parameter once the read operation is done.
-   * The callback will be called when the operation is done.
+   * Reads text lines from a file.
+   * @param {string} fileName
+   *    Name of the file to be read
+   * @param {TextSink} listener
+   *    Function that will be called for each line in the file
+   * @return {Promise}
+   *    Promise to be resolved or rejected once the operation is completed
    */
-  readFromFile(/**nsIFile*/ file, /**Object*/ listener, /**Function*/ callback)
+  readFromFile(fileName, listener)
   {
-    attachCallback(
-      callWebExt("readFromFile", file.leafName).then(contents =>
+    return callWebExt("readFromFile", fileName).then(contents =>
+    {
+      return new Promise((resolve, reject) =>
       {
-        return new Promise((resolve, reject) =>
+        let lineIndex = 0;
+
+        function processBatch()
         {
-          let lineIndex = 0;
+          while (lineIndex < contents.length)
+          {
+            listener(contents[lineIndex++]);
+            if (lineIndex % 1000 == 0)
+            {
+              Utils.runAsync(processBatch);
+              return;
+            }
+          }
+          resolve();
+        }
 
-          function processBatch()
+        processBatch();
+      });
+    }).catch(error =>
+    {
+      if (error == "NoSuchFile")
+      {
+        let wrapper = {
+          process(line)
           {
-            while (lineIndex < contents.length)
-            {
-              listener.process(contents[lineIndex++]);
-              if (lineIndex % 1000 == 0)
-              {
-                Utils.runAsync(processBatch);
-                return;
-              }
-            }
-
-            listener.process(null);
-            resolve();
+            if (line !== null)
+              listener(line);
           }
-
-          processBatch();
-        });
-      }),
-      callback,
-      () => LegacyIO.readFromFile(file, listener, callback)
-    );
+        };
+        return callLegacy("readFromFile", legacyFile(fileName), wrapper);
+      }
+      throw error;
+    });
   },
 
   /**
-   * Writes string data to a file in UTF-8 format asynchronously. The callback
-   * will be called when the write operation is done.
+   * Writes text lines to a file.
+   * @param {string} fileName
+   *    Name of the file to be written
+   * @param {Iterable.<string>} data
+   *    An array-like or iterable object containing the lines (without line
+   *    endings)
+   * @return {Promise}
+   *    Promise to be resolved or rejected once the operation is completed
    */
-  writeToFile(/**nsIFile*/ file, /**Iterator*/ data, /**Function*/ callback)
+  writeToFile(fileName, data)
   {
-    attachCallback(
-      callWebExt("writeToFile", file.leafName, Array.from(data)),
-      callback
-    );
+    return callWebExt("writeToFile", fileName, Array.from(data));
   },
 
   /**
-   * Copies a file asynchronously. The callback will be called when the copy
-   * operation is done.
+   * Copies a file.
+   * @param {string} fromFile
+   *    Name of the file to be copied
+   * @param {string} toFile
+   *    Name of the file to be written, will be overwritten if exists
+   * @return {Promise}
+   *    Promise to be resolved or rejected once the operation is completed
    */
-  copyFile(/**nsIFile*/ fromFile, /**nsIFile*/ toFile, /**Function*/ callback)
+  copyFile(fromFile, toFile)
   {
-    attachCallback(
-      callWebExt("copyFile", fromFile.leafName, toFile.leafName),
-      callback,
-      () => LegacyIO.copyFile(fromFile, toFile, callback)
-    );
+    return callWebExt("copyFile", fromFile, toFile).catch(error =>
+    {
+      if (error == "NoSuchFile")

[kzar, 2017/04/20 10:25:07]

It seems like this pattern is repeated quite a bit, could you abstract it?

[Wladimir Palant, 2017/04/20 12:02:06]

I thought about it but couldn't see a way requiring less complexity than there
is right now. Do you have any suggestions?

[kzar, 2017/04/20 12:11:59]

Hmm I guess not. I didn't realise the arguments passed to callLegacy vary
slightly. Fair enough.

+        return callLegacy("copyFile", legacyFile(fromFile), legacyFile(toFile));
+      throw error;
+    });
   },
 
   /**
-   * Renames a file within the same directory, will call callback when done.
+   * Renames a file.
+   * @param {string} fromFile
+   *    Name of the file to be renamed
+   * @param {string} newName
+   *    New file name, will be overwritten if exists
+   * @return {Promise}
+   *    Promise to be resolved or rejected once the operation is completed
    */
-  renameFile(/**nsIFile*/ fromFile, /**String*/ newName, /**Function*/ callback)
+  renameFile(fromFile, newName)
   {
-    attachCallback(
-      callWebExt("renameFile", fromFile.leafName, newName),
-      callback,
-      () => LegacyIO.renameFile(fromFile, newName, callback)
-    );
+    return callWebExt("renameFile", fromFile, newName).catch(error =>
+    {
+      if (error == "NoSuchFile")
+        return callLegacy("renameFile", legacyFile(fromFile), newName);
+      throw error;
+    });
   },
 
   /**
-   * Removes a file, will call callback when done.
+   * Removes a file.
+   * @param {string} fileName
+   *    Name of the file to be removed
+   * @return {Promise}
+   *    Promise to be resolved or rejected once the operation is completed
    */
-  removeFile(/**nsIFile*/ file, /**Function*/ callback)
+  removeFile(fileName)
   {
-    attachCallback(
-      callWebExt("removeFile", file.leafName),
-      callback,
-      () => LegacyIO.removeFile(file, callback)
-    );
+    return callWebExt("removeFile", fileName).catch(error =>
+    {
+      if (error == "NoSuchFile")
+        return callLegacy("removeFile", legacyFile(fileName));
+      throw error;
+    });
   },
 
   /**
-   * Gets file information such as whether the file exists.
+   * @typedef StatData
+   * @type {object}
+   * @property {boolean} exists
+   *    true if the file exists
+   * @property {number} lastModified
+   *    file modification time in milliseconds
    */
-  statFile(/**nsIFile*/ file, /**Function*/ callback)
+
+  /**
+   * Retrieves file metadata.
+   * @param {string} fileName
+   *    Name of the file to be looked up
+   * @return {Promise.<StatData>}
+   *    Promise to be resolved with file metadata once the operation is
+   *    completed
+   */
+  statFile(fileName)
   {
-    attachCallback(
-      callWebExt("statFile", file.leafName),
-      callback,
-      () => LegacyIO.statFile(file, callback)
-    );
+    return callWebExt("statFile", fileName).catch(error =>
+    {
+      if (error == "NoSuchFile")
+        return callLegacy("statFile", legacyFile(fileName));
+      throw error;
+    });
   }
 };