@maizzle/framework 4.0.0-alpha.1 → 4.0.0-alpha.10

package/test/test-todisk.js

@@ -67,9 +67,9 @@ test('outputs files at the correct location', async t => {
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(string.length, 3)
-  t.is(array.length, 3)
+  t.true(await fs.pathExists(t.context.folder))
+  t.is(string.length, 2)
+  t.is(array.length, 2)
 })
 
 test('outputs files at the correct location if multiple template sources are used', async t => {
@@ -93,8 +93,8 @@ test('outputs files at the correct location if multiple template sources are use
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(files.length, 4)
+  t.true(await fs.pathExists(t.context.folder))
+  t.is(files.length, 3)
 })
 
 test('copies all files in the `filetypes` option to destination', async t => {
@@ -103,7 +103,7 @@ test('copies all files in the `filetypes` option to destination', async t => {
       fail: 'silent',
       templates: {
         source: 'test/stubs/templates',
-        filetypes: ['html', 'mzl'],
+        filetypes: ['html', 'test'],
         destination: {
           path: t.context.folder
         }
@@ -116,8 +116,8 @@ test('copies all files in the `filetypes` option to destination', async t => {
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(files.length, 4)
+  t.true(await fs.pathExists(t.context.folder))
+  t.is(files.length, 3)
 })
 
 test('outputs files with the correct extension', async t => {
@@ -139,7 +139,9 @@ test('outputs files with the correct extension', async t => {
     }
   })
 
-  t.true(fs.readdirSync(t.context.folder).includes('1.blade.php'))
+  const filelist = await fs.readdir(t.context.folder)
+
+  t.true(filelist.includes('1.blade.php'))
 })
 
 test('outputs plaintext files', async t => {
@@ -228,8 +230,10 @@ test('copies assets to destination', async t => {
     }
   })
 
-  t.is(fs.pathExistsSync(`${t.context.folder}/images`), true)
-  t.is(fs.readdirSync(`${t.context.folder}/images`).length, 1)
+  const filelist = await fs.readdir(`${t.context.folder}/images`)
+
+  t.is(await fs.pathExists(`${t.context.folder}/images`), true)
+  t.is(filelist.length, 1)
 })
 
 test('runs the `beforeCreate` event', async t => {
@@ -255,9 +259,10 @@ test('runs the `beforeCreate` event', async t => {
     }
   })
 
-  const html = fs.readFileSync(`${t.context.folder}/${fs.readdirSync(t.context.folder)[0]}`, 'utf8').trim()
+  const filename = await fs.readdir(t.context.folder)
+  const html = await fs.readFile(`${t.context.folder}/${filename[0]}`, 'utf8')
 
-  t.is(html, 'Foo is bar')
+  t.is(html.trim(), 'Foo is bar')
 })
 
 test('runs the `afterBuild` event', async t => {
@@ -310,9 +315,9 @@ test('supports multiple asset paths', async t => {
     }
   })
 
-  t.true(fs.existsSync(`${t.context.folder}/extras/foo.bar`))
-  t.true(fs.existsSync(`${t.context.folder}/extras/plaintext.html`))
-  t.false(fs.existsSync(`${t.context.folder}/extras/invalid`))
+  t.true(await fs.pathExists(`${t.context.folder}/extras/foo.bar`))
+  t.true(await fs.pathExists(`${t.context.folder}/extras/plaintext.html`))
+  t.false(await fs.pathExists(`${t.context.folder}/extras/invalid`))
 })
 
 test('warns if a template cannot be rendered and `fail` option is undefined', async t => {
@@ -392,31 +397,42 @@ test('spins up local development server', async t => {
     }
   })
 
-  t.true(fs.existsSync(t.context.folder))
+  t.true(await fs.pathExists(t.context.folder))
 })
 
 test('local server does not compile unwanted file types', async t => {
   await Maizzle.serve('local', {
     build: {
+      console: {
+        clear: true
+      },
       browsersync: {
         ui: false
       },
       templates: {
         source: 'test/stubs/templates',
         destination: {
-          path: t.context.folder
+          path: `${t.context.folder}`
         }
       }
+    },
+    events: {
+      beforeCreate(config) {
+        config.foo = 'bar'
+      }
     }
   })
 
-  fs.outputFileSync(`test/stubs/templates/1.html`, '<a href="https://example.com">Test</a>\n')
-  fs.outputFileSync(`test/stubs/templates/3.mzl`, '<a href="https://example.com">Test</a>\n')
+  t.true(await fs.pathExists(`${t.context.folder}`))
+  t.true(await fs.pathExists(`${t.context.folder}/2.test`))
 
-  t.is(fs.readFileSync(`${t.context.folder}/1.html`, 'utf8'), '<a href="https://example.com">Test</a>\n')
-  t.is(fs.readFileSync(`${t.context.folder}/3.mzl`, 'utf8'), '<a href="https://example.com">Test</a>\n')
+  // Tests watching changes to files
+  await fs.outputFile('test/stubs/templates/1.html', 'html\n')
+  t.is(await fs.readFile('test/stubs/templates/1.html', 'utf8'), 'html\n')
 
-  fs.removeSync(t.context.folder)
+  // Don't trigger rebuilds on files not in filetypes
+  await fs.outputFile('test/stubs/templates/2.test', 'test\n')
+  t.is(await fs.readFile('test/stubs/templates/2.test', 'utf8'), 'test\n')
 })
 
 test('throws if it cannot spin up local development server', async t => {
@@ -438,16 +454,19 @@ test('works with templates.source defined as function (string paths)', async t =
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(files.length, 3)
+  t.true(await fs.pathExists(t.context.folder))
+  t.is(files.length, 2)
 })
 
 test('works with templates.source defined as function (array paths)', async t => {
   const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
+      customSources: ['test/stubs/templates', 'test/stubs/templates'],
       templates: {
-        source: () => ['test/stubs/templates', 'test/stubs/templates'],
+        source: config => {
+          return config.build.customSources
+        },
         destination: {
           path: t.context.folder
         }
@@ -455,6 +474,38 @@ test('works with templates.source defined as function (array paths)', async t =>
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(files.length, 3)
+  t.true(await fs.pathExists(t.context.folder))
+  t.is(files.length, 2)
+})
+
+test('throws if templates path is invalid', async t => {
+  await t.throwsAsync(async () => {
+    await Maizzle.build('maizzle-ci', {
+      build: {
+        fail: 'silent',
+        templates: {
+          source: false,
+          destination: {
+            path: t.context.folder
+          }
+        }
+      }
+    })
+  }, {instanceOf: TypeError})
+})
+
+test('throws if templates path is invalid (function)', async t => {
+  await t.throwsAsync(async () => {
+    await Maizzle.build('maizzle-ci', {
+      build: {
+        fail: 'silent',
+        templates: {
+          source: () => {},
+          destination: {
+            path: t.context.folder
+          }
+        }
+      }
+    })
+  }, {instanceOf: TypeError})
 })

package/test/test-tostring.js

@@ -1,132 +1,148 @@
-const test = require('ava')
-const Maizzle = require('../src')
-
-const path = require('path')
-const {readFileSync} = require('fs')
-
-const fixture = file => readFileSync(path.join(__dirname, 'fixtures', `${file}.html`), 'utf8')
-const expected = file => readFileSync(path.join(__dirname, 'expected', `${file}.html`), 'utf8')
-
-const renderString = (string, options = {}) => Maizzle.render(string, options).then(({html}) => html)
-
-test('compiles HTML string if no options are passed', async t => {
-  const source = fixture('basic')
-
-  const html = await renderString(source)
-
-  t.is(html, source)
-})
-
-test('uses environment config file(s) if available', async t => {
-  const source = fixture('useConfig')
-
-  const html = await renderString(source, {maizzle: {env: 'maizzle-ci'}})
-
-  t.is(html, expected('useConfig'))
-})
-
-test('inheritance', async t => {
-  let html = await renderString(fixture('inheritance'))
-  html = html.replace(/[^\S\r\n]+$/gm, '').trim()
-
-  t.is(html, expected('inheritance').trim())
-})
-
-test('throws if first argument is not an HTML string', async t => {
-  await t.throwsAsync(async () => {
-    await renderString(false)
-  }, {instanceOf: TypeError, message: 'first argument must be an HTML string, received false'})
-})
-
-test('throws if first argument is an empty string', async t => {
-  await t.throwsAsync(async () => {
-    await renderString('')
-  }, {instanceOf: RangeError, message: 'received empty string'})
-})
-
-test('runs the `beforeRender` event', async t => {
-  const html = await renderString(`<div>{{ page.foo }}</div>`, {
-    beforeRender(html, config) {
-      config.foo = 'bar'
-
-      return html
-    }
-  })
-
-  t.is(html, `<div>bar</div>`)
-})
-
-test('runs the `afterRender` event', async t => {
-  const result = await renderString(`<div>foo</div>`, {
-    afterRender(html, config) {
-      config.replaceStrings = {
-        foo: 'baz'
-      }
-
-      return html
-    }
-  })
-
-  t.is(result, `<div>baz</div>`)
-})
-
-test('runs the `afterTransformers` event', async t => {
-  const result = await renderString(`<div>foo</div>`, {
-    maizzle: {
-      title: 'bar'
-    },
-    afterTransformers(html, config) {
-      return html.replace('foo', config.title)
-    }
-  })
-
-  t.is(result, `<div>bar</div>`)
-})
-
-test('multiple locals', async t => {
-  const result = await renderString(`{{ page.one }}, {{ two }}, {{ three }}`, {
-    maizzle: {
-      one: 1,
-      build: {
-        posthtml: {
-          expressions: {
-            locals: {
-              two: 2
-            }
-          }
-        }
-      },
-      locals: {
-        three: 3
-      }
-    }
-  })
-
-  t.is(result, `1, 2, 3`)
-})
-
-test('prevents overwriting page object', async t => {
-  const result = await renderString(`{{ page.one }}, {{ two }}, {{ three }}`, {
-    maizzle: {
-      one: 1,
-      build: {
-        posthtml: {
-          expressions: {
-            locals: {
-              page: {
-                two: 2
-              }
-            }
-          }
-        }
-      },
-      locals: {
-        page: {
-          three: 3
-        }
-      }
-    }
-  })
-
-  t.is(result, `1, undefined, undefined`)
-})
+const test = require('ava')
+const Maizzle = require('../src')
+
+const path = require('path')
+const fs = require('fs')
+
+const readFile = (dir, filename) => fs.promises
+  .readFile(path.join(__dirname, dir, `${filename}.html`), 'utf8')
+  .then(html => html.trim())
+
+const fixture = file => readFile('fixtures', file)
+const expected = file => readFile('expected', file)
+
+const renderString = (string, options = {}) => Maizzle.render(string, options).then(({html}) => html)
+
+test('compiles HTML string if no options are passed', async t => {
+  const source = await fixture('basic')
+
+  const html = await renderString(source)
+
+  t.is(html, source)
+})
+
+test('uses environment config file(s) if available', async t => {
+  const source = await fixture('useConfig')
+
+  const html = await renderString(source, {maizzle: {env: 'maizzle-ci'}})
+
+  t.is(html, await expected('useConfig'))
+})
+
+test('throws if first argument is not an HTML string', async t => {
+  await t.throwsAsync(async () => {
+    await renderString()
+  }, {instanceOf: TypeError, message: 'first argument must be an HTML string, received undefined'})
+})
+
+test('throws if first argument is an empty string', async t => {
+  await t.throwsAsync(async () => {
+    await renderString('')
+  }, {instanceOf: RangeError, message: 'received empty string'})
+})
+
+test('runs the `beforeRender` event', async t => {
+  const html = await renderString(`<div>{{ page.foo }}</div>`, {
+    beforeRender(html, config) {
+      config.foo = 'bar'
+
+      return html
+    }
+  })
+
+  t.is(html, `<div>bar</div>`)
+})
+
+test('runs the `afterRender` event', async t => {
+  const result = await renderString(`<div>foo</div>`, {
+    afterRender(html, config) {
+      config.replaceStrings = {
+        foo: 'baz'
+      }
+
+      return html
+    }
+  })
+
+  t.is(result, `<div>baz</div>`)
+})
+
+test('runs the `afterTransformers` event', async t => {
+  const result = await renderString(`<div>foo</div>`, {
+    maizzle: {
+      title: 'bar'
+    },
+    afterTransformers(html, config) {
+      return html.replace('foo', config.title)
+    }
+  })
+
+  t.is(result, `<div>bar</div>`)
+})
+
+test('locals work when defined in all supported places', async t => {
+  const result = await renderString(`{{ page.one }}, {{ two }}, {{ three }}`, {
+    maizzle: {
+      one: 1,
+      build: {
+        posthtml: {
+          expressions: {
+            locals: {
+              two: 2
+            }
+          }
+        }
+      },
+      locals: {
+        three: 3
+      }
+    }
+  })
+
+  t.is(result, `1, 2, 3`)
+})
+
+test('prevents overwriting page object', async t => {
+  const result = await renderString(`{{ page.one }}, {{ two }}, {{ three }}`, {
+    maizzle: {
+      one: 1,
+      build: {
+        posthtml: {
+          expressions: {
+            locals: {
+              page: {
+                two: 2
+              }
+            }
+          }
+        }
+      },
+      locals: {
+        page: {
+          three: 3
+        }
+      }
+    }
+  })
+
+  t.is(result, `1, undefined, undefined`)
+})
+
+test('preserves css in marked style tags (tailwindcss)', async t => {
+  const source = await fixture('transformers/preserve-transform-css')
+  const html = await renderString(source, {
+    // So that we don't compile twice
+    tailwind: {
+      compiled: ''
+    }
+  })
+
+  t.is(html, await expected('transformers/preserve-transform-css'))
+})
+
+test('@import css files in marked style tags', async t => {
+  const source = await fixture('transformers/atimport-in-style')
+  const html = await renderString(source)
+
+  t.is(html, await expected('transformers/atimport-in-style'))
+})