Issue 6538, 6781 - Implement script compilation for snippets

lib/snippets.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 111 matching lines @@
 
         if (character == ";" && call.length > 0)
         {
           tree.push(call);
           call = [];
         }
       }
     }
 
     return tree;
+  },
+
+  /**
+   * Compiles a script against a given list of libraries into executable code
+   * @param {string} script
+   * @param {string[]} libraries
+   * @return {string}
+   */
+  compileScript(script, libraries)
+  {
+    return `
+      "use strict";
+      {
+        const libraries = ${JSON.stringify(libraries)};
+
+        const script = ${JSON.stringify(Snippets.parseScript(script))};
+
+        let imports = Object.create(null);

[Manish Jethani, 2018/04/26 13:46:00]

There's an imports object and it gets populated by the "library". The library is
just a JavaScript module like the following:

  // my-lib.js
  exports.foo = function()
  {
    console.log("foo");
  };

Where does my-lib.js get the exports object? We pass our "imports" object to it
as an argument, which becomes its exports object. This way we load multiple
libraries and all of them populate the same exports object.

The reason for supporting multiple libraries is that we want to have an initial
local library (bundled with the extension) and then have a remote library loaded
and updated at regular intervals, which overrides the local library. Also at
some point we might want to split up our snippets into multiple libraries for
organization purposes (and to make the downloads smaller so you only download
what you need).

+        for (let library of libraries)
+          new Function("exports", library)(imports);
+
+        for (let [name, ...args] of script)
+        {
+          if (Object.prototype.hasOwnProperty.call(imports, name))
+          {
+            let value = imports[name];

[Manish Jethani, 2018/04/26 13:46:00]

Note that the function must exist directly on the imports object, hence no
chance of calling window.eval and things like that.

+            if (typeof value == "function")
+              value(...args);

[Manish Jethani, 2018/04/26 13:46:00]

Also note that the function is called without a "this". It still has access to
its file scope.

  //my-lib.js
  let foo = 0;
  exports.setFoo = function(value)
  {
    foo = value;
  }

Calling setFoo here without a "this" will still set the value of foo. This is
explicitly tested in the unit tests.

Each script execution happens with a new instance of the library so the value of
foo won't be retained between script executions. This is also explicitly tested
in the unit tests.

Basically we want things to be as stateless as possible; script execution on one
site should not have any effect on other sites where the same script executes.
State can be shared within the same script (e.g. "setFoo 123; checkFoo 123") but
this is only incidental and not by design. We won't have any global variables in
our snippets library so there will be nothing to share in practice.

+          }
+        }
+      }
+    `;
   }
 };
 
 exports.Snippets = Snippets;