Merge branch 'parellel-promises' of https://github.com/NotWoods/eleventy

 into NotWoods-parellel-promises

# Conflicts:
#	src/Engines/Html.js
#	src/Engines/Liquid.js
#	src/Template.js

src/Eleventy.js

@@ -676,7 +676,7 @@ Arguments:
     this.watcher = watcher;
 
     let watchDelay;
-    async function watchRun(path) {
+    let watchRun = async (path) => {
       try {
         this._addFileToWatchQueue(path);
         clearTimeout(watchDelay);
@@ -687,16 +687,16 @@ Arguments:
         EleventyErrorHandler.fatal(e, "Eleventy fatal watch error");
         this.stopWatch();
       }
-    }
+    };
 
     watcher.on("change", async (path) => {
       console.log("File changed:", path);
-      await watchRun.call(this, path);
+      await watchRun(path);
     });
 
     watcher.on("add", async (path) => {
       console.log("File added:", path);
-      await watchRun.call(this, path);
+      await watchRun(path);
     });
 
     process.on("SIGINT", () => this.stopWatch());

src/Engines/Html.js

@@ -13,9 +13,11 @@ class Html extends TemplateEngine {
         super.getIncludesDir(),
         this.extensionMap
       );
-      let fn = await engine.compile(str, inputPath);
+      let fnReady = engine.compile(str, inputPath);
 
       return async function (data) {
+        let fn = await fnReady;
+
         return fn(data);
       };
     } else {

src/Engines/Liquid.js

@@ -203,7 +203,7 @@ class Liquid extends TemplateEngine {
 
   async compile(str, inputPath) {
     let engine = this.liquidLib;
-    let tmpl = await engine.parse(str, inputPath);
+    let tmplReady = engine.parse(str, inputPath);
 
     // Required for relative includes
     let options = {};
@@ -215,7 +215,10 @@ class Liquid extends TemplateEngine {
         TemplatePath.getDirFromFilePath(inputPath),
       ];
     }
+
     return async function (data) {
+      let tmpl = await tmplReady;
+
       return engine.render(tmpl, data, options);
     };
   }

src/Engines/Markdown.js

@@ -20,7 +20,7 @@ class Markdown extends TemplateEngine {
     // This is separate so devs can pass in a new mdLib and still use the official eleventy plugin for markdown highlighting
     if (this.config.markdownHighlighter) {
       this.mdLib.set({
-        highlight: this.config.markdownHighlighter
+        highlight: this.config.markdownHighlighter,
       });
     }
 
@@ -39,7 +39,7 @@ class Markdown extends TemplateEngine {
 
     return Object.assign(
       {
-        html: true
+        html: true,
       },
       this.markdownOptions || {}
     );
@@ -49,8 +49,6 @@ class Markdown extends TemplateEngine {
     let mdlib = this.mdLib;
 
     if (preTemplateEngine) {
-      let fn;
-
       let engine;
       if (typeof preTemplateEngine === "string") {
         engine = this.engineManager.getEngine(
@@ -62,26 +60,28 @@ class Markdown extends TemplateEngine {
         engine = preTemplateEngine;
       }
 
-      fn = await engine.compile(str, inputPath);
+      let fnReady = engine.compile(str, inputPath);
 
       if (bypassMarkdown) {
-        return async function(data) {
+        return async function (data) {
+          let fn = await fnReady;
           return fn(data);
         };
       } else {
-        return async function(data) {
+        return async function (data) {
+          let fn = await fnReady;
           let preTemplateEngineRender = await fn(data);
           let finishedRender = mdlib.render(preTemplateEngineRender, data);
           return finishedRender;
         };
       }
     } else {
       if (bypassMarkdown) {
-        return function() {
+        return function () {
           return str;
         };
       } else {
-        return function(data) {
+        return function (data) {
           return mdlib.render(str, data);
         };
       }

src/Engines/TemplateEngine.js

@@ -131,7 +131,7 @@ class TemplateEngine {
       let fn = await this.compile(str);
       return fn(data);
     } catch (e) {
-      return Promise.reject(e);
+      throw e;
     }
   }
 

src/Plugins/Pagination.js

@@ -239,8 +239,12 @@ class Pagination {
       cloned.setPaginationData(override);
 
       // TO DO subdirectory to links if the site doesn’t live at /
-      links.push("/" + (await cloned.getOutputLink()));
-      hrefs.push(await cloned.getOutputHref());
+      let [outputLink, outputHref] = await Promise.all([
+        cloned.getOutputLink(),
+        cloned.getOutputHref(),
+      ]);
+      links.push("/" + outputLink);
+      hrefs.push(outputHref);
     }
 
     // we loop twice to pass in the appropriate prev/next links (already full generated now)

src/Template.js

@@ -194,19 +194,19 @@ class Template extends TemplateContent {
       let str = await super.render(data, templateData, true);
       return str;
     } else if (Array.isArray(data)) {
-      let arr = [];
-      for (let j = 0, k = data.length; j < k; j++) {
-        arr.push(await this.mapDataAsRenderedTemplates(data[j], templateData));
-      }
-      return arr;
+      return Promise.all(
+        data.map((item) => this.mapDataAsRenderedTemplates(item, templateData))
+      );
     } else if (lodashIsObject(data)) {
       let obj = {};
-      for (let value in data) {
-        obj[value] = await this.mapDataAsRenderedTemplates(
-          data[value],
-          templateData
-        );
-      }
+      await Promise.all(
+        Object.keys(data).map(async (value) => {
+          obj[value] = await this.mapDataAsRenderedTemplates(
+            data[value],
+            templateData
+          );
+        })
+      );
       return obj;
     }
 
@@ -463,85 +463,90 @@ class Template extends TemplateContent {
   }
 
   async getTemplates(data) {
-    let results = [];
-
     if (!Pagination.hasPagination(data)) {
       await this.addComputedData(data);
 
-      results.push({
-        template: this,
-        inputPath: this.inputPath,
-        fileSlug: this.fileSlugStr,
-        filePathStem: this.filePathStem,
-        data: data,
-        date: data.page.date,
-        outputPath: data.page.outputPath,
-        url: data.page.url,
-        set templateContent(content) {
-          this._templateContent = content;
-        },
-        get templateContent() {
-          if (this._templateContent === undefined) {
-            // should at least warn here
-            throw new TemplateContentPrematureUseError(
-              `Tried to use templateContent too early (${this.inputPath})`
-            );
-          }
-          return this._templateContent;
-        },
-      });
-    } else {
-      // needs collections for pagination items
-      // but individual pagination entries won’t be part of a collection
-      this.paging = new Pagination(data);
-      this.paging.setTemplate(this);
-      let pageTemplates = await this.paging.getPageTemplates();
-      let pageNumber = 0;
-      for (let page of pageTemplates) {
-        let pageData = Object.assign({}, await page.getData());
-
-        await page.addComputedData(pageData);
-
-        // Issue #115
-        if (data.collections) {
-          pageData.collections = data.collections;
-        }
-
-        results.push({
-          template: page,
+      return [
+        {
+          template: this,
           inputPath: this.inputPath,
           fileSlug: this.fileSlugStr,
           filePathStem: this.filePathStem,
-          data: pageData,
-          date: pageData.page.date,
-          pageNumber: pageNumber++,
-          outputPath: pageData.page.outputPath,
-          url: pageData.page.url,
+          data: data,
+          date: data.page.date,
+          outputPath: data.page.outputPath,
+          url: data.page.url,
           set templateContent(content) {
             this._templateContent = content;
           },
           get templateContent() {
             if (this._templateContent === undefined) {
+              // should at least warn here
               throw new TemplateContentPrematureUseError(
-                `Tried to use templateContent too early (${this.inputPath} page ${this.pageNumber})`
+                `Tried to use templateContent too early (${this.inputPath})`
               );
             }
             return this._templateContent;
           },
-        });
-      }
-    }
+        },
+      ];
+    } else {
+      // needs collections for pagination items
+      // but individual pagination entries won’t be part of a collection
+      this.paging = new Pagination(data);
+      this.paging.setTemplate(this);
+      let pageTemplates = await this.paging.getPageTemplates();
+
+      return await Promise.all(
+        pageTemplates.map(async (page, pageNumber) => {
+          let pageData = Object.assign({}, await page.getData());
 
-    return results;
+          await page.addComputedData(pageData);
+
+          // Issue #115
+          if (data.collections) {
+            pageData.collections = data.collections;
+          }
+
+          return {
+            template: page,
+            inputPath: this.inputPath,
+            fileSlug: this.fileSlugStr,
+            filePathStem: this.filePathStem,
+            data: pageData,
+            date: pageData.page.date,
+            pageNumber: pageNumber,
+            outputPath: pageData.page.outputPath,
+            url: pageData.page.url,
+            set templateContent(content) {
+              this._templateContent = content;
+            },
+            get templateContent() {
+              if (this._templateContent === undefined) {
+                throw new TemplateContentPrematureUseError(
+                  `Tried to use templateContent too early (${this.inputPath} page ${this.pageNumber})`
+                );
+              }
+              return this._templateContent;
+            },
+          };
+        })
+      );
+    }
   }
 
   async getRenderedTemplates(data) {
     let pages = await this.getTemplates(data);
-    for (let page of pages) {
-      let content = await page.template._getContent(page.outputPath, page.data);
+    await Promise.all(
+      pages.map(async (page) => {
+        let content = await page.template._getContent(
+          page.outputPath,
+          page.data
+        );
 
-      page.templateContent = content;
-    }
+        page.templateContent = content;
+      })
+    );
     return pages;
   }
 
@@ -618,14 +623,12 @@ class Template extends TemplateContent {
   }
 
   async writeMapEntry(mapEntry) {
-    let promises = [];
-    for (let page of mapEntry._pages) {
-      let content = await this.renderPageEntry(mapEntry, page);
-      let promise = this._write(page.outputPath, content);
-      promises.push(promise);
-    }
-
-    return Promise.all(promises);
+    await Promise.all(
+      mapEntry._pages.map(async (page) => {
+        let content = await this.renderPageEntry(mapEntry, page);
+        return this._write(page.outputPath, content);
+      })
+    );
   }
 
   // TODO is this still used by anything but tests?
@@ -636,7 +639,7 @@ class Template extends TemplateContent {
       promises.push(this._write(tmpl.outputPath, tmpl.templateContent));
     }
 
-    return Promise.all(promises);
+    await Promise.all(promises);
   }
 
   // TODO this but better
@@ -763,19 +766,22 @@ class Template extends TemplateContent {
 
   async _testCompleteRender() {
     let entries = await this.getTemplateMapEntries();
-    let contents = [];
 
-    for (let entry of entries) {
-      entry._pages = await entry.template.getTemplates(entry.data);
+    let nestedContent = await Promise.all(
+      entries.map(async (entry) => {
+        entry._pages = await entry.template.getTemplates(entry.data);
+        return Promise.all(
+          entry._pages.map(async (page) => {
+            page.templateContent = await entry.template.getTemplateMapContent(
+              page
+            );
+            return this.renderPageEntry(entry, page);
+          })
+        );
+      })
+    );
 
-      let page;
-      for (page of entry._pages) {
-        page.templateContent = await entry.template.getTemplateMapContent(page);
-      }
-      for (page of entry._pages) {
-        contents.push(await this.renderPageEntry(entry, page));
-      }
-    }
+    let contents = [].concat(...nestedContent);
     return contents;
   }
 }