@maizzle/framework 3.7.2 → 4.0.0-alpha.10

package/test/test-tailwindcss.js

@@ -0,0 +1,117 @@
+const test = require('ava')
+const ora = require('ora')
+const Tailwind = require('../src/generators/tailwindcss')
+
+test('throws on compile error', async t => {
+  await t.throwsAsync(async () => {
+    const spinner = ora('Compiling Tailwind CSS...').start()
+    await Tailwind.compile('.test {@apply inexistent;}', '<div class="test">Test</a>', {}, {}, spinner)
+  }, {instanceOf: Error, message: 'Tailwind CSS compilation failed'})
+})
+
+test('uses defaults if no config specified', async t => {
+  const css = await Tailwind.compile(
+    '@tailwind utilities;',
+    '<p class="xl:z-0"></p>',
+    {},
+    {env: 'production'}
+  )
+
+  t.not(css, undefined)
+  t.true(css.includes('.xl\\:z-0'))
+})
+
+test('uses css file provided in environment config', async t => {
+  const config = {
+    env: 'production',
+    build: {
+      tailwind: {
+        css: './test/stubs/main.css'
+      }
+    }
+  }
+
+  const css = await Tailwind.compile('', '<div class="text-center foo">test</div>', {}, config)
+
+  t.not(css, undefined)
+  t.true(css.includes('.text-center'))
+  t.true(css.includes('.foo'))
+})
+
+test('works with custom `content` sources', async t => {
+  const css = await Tailwind.compile(
+    '@tailwind utilities;',
+    '<div class="hidden"></div>',
+    {
+      content: ['./test/stubs/tailwind/*.*']
+    }
+  )
+
+  t.true(css.includes('.hidden'))
+})
+
+test('works with custom `files` sources', async t => {
+  const css = await Tailwind.compile(
+    '@tailwind utilities;',
+    '<div></div>',
+    {
+      content: {
+        files: ['./test/stubs/tailwind/*.*']
+      }
+    }
+  )
+
+  t.true(css.includes('.hidden'))
+})
+
+test('uses maizzle template path as content source', async t => {
+  const css = await Tailwind.compile(
+    '@tailwind utilities;',
+    '<div></div>',
+    {},
+    {
+      build: {
+        templates: {
+          source: './test/stubs/tailwind'
+        }
+      }
+    }
+  )
+
+  t.true(css.includes('.hidden'))
+})
+
+test('uses maizzle template path as content source (single file)', async t => {
+  const css = await Tailwind.compile(
+    '@tailwind utilities;',
+    '<div></div>',
+    {},
+    {
+      build: {
+        templates: {
+          source: './test/stubs/tailwind/content-source.html'
+        }
+      }
+    }
+  )
+
+  t.true(css.includes('.hidden'))
+})
+
+test('uses custom postcss plugins from the maizzle config', async t => {
+  const maizzleConfig = {
+    env: 'production',
+    build: {
+      postcss: {
+        plugins: [
+          require('autoprefixer')({overrideBrowserslist: ['> 0.1%']})
+        ]
+      }
+    }
+  }
+
+  const css = await Tailwind.compile('.test {transform: scale(0.5)}', '<div class="test">Test</a>', {}, maizzleConfig)
+
+  t.not(css, undefined)
+  t.is(css.trim(), '.inline {display: inline !important} .table {display: table !important} .contents {display: contents !important} .truncate {overflow: hidden !important;text-overflow: ellipsis !important;white-space: nowrap !important} .uppercase {text-transform: uppercase !important} .lowercase {text-transform: lowercase !important} .capitalize {text-transform: capitalize !important} .test {-webkit-transform: scale(0.5);transform: scale(0.5)}')
+})

package/test/test-todisk.js

@@ -16,12 +16,12 @@ test.afterEach.always(async t => {
 
 test('throws if config cannot be computed', async t => {
   await t.throwsAsync(async () => {
-    await Maizzle.build('production')
-  }, {instanceOf: Error, message: `could not load config.production.js`})
+    await Maizzle.build('missing')
+  }, {instanceOf: Error, message: `could not load config.missing.js`})
 })
 
 test('skips if no templates found', async t => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -43,7 +43,7 @@ test('skips if no templates found', async t => {
 })
 
 test('outputs files at the correct location', async t => {
-  const {files} = await Maizzle.build('production', {
+  const {files: string} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -51,17 +51,25 @@ test('outputs files at the correct location', async t => {
         destination: {
           path: t.context.folder
         }
-      },
-      tailwind: {
-        config: {
-          purge: false
+      }
+    }
+  })
+
+  const {files: array} = await Maizzle.build('maizzle-ci', {
+    build: {
+      fail: 'silent',
+      templates: {
+        source: ['test/stubs/templates'],
+        destination: {
+          path: t.context.folder
         }
       }
     }
   })
 
-  t.true(fs.pathExistsSync(t.context.folder))
-  t.is(files.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 => {
@@ -85,17 +93,17 @@ 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 => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
         source: 'test/stubs/templates',
-        filetypes: ['html', 'mzl'],
+        filetypes: ['html', 'test'],
         destination: {
           path: t.context.folder
         }
@@ -108,12 +116,12 @@ 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 => {
-  await Maizzle.build('production', {
+  await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -131,26 +139,28 @@ 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 => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     fail: 'silent',
     build: {
       templates: {
         source: 'test/stubs/plaintext',
         destination: {
           path: t.context.folder
-        }
+        },
+        plaintext: true
       },
       tailwind: {
         config: {
           purge: false
         }
       }
-    },
-    plaintext: true
+    }
   })
 
   const plaintext = files.filter(file => file.includes('.txt'))
@@ -164,13 +174,18 @@ test('outputs plaintext files', async t => {
 })
 
 test('outputs plaintext files (custom path)', async t => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     fail: 'silent',
     build: {
       templates: {
         source: 'test/stubs/plaintext',
         destination: {
           path: t.context.folder
+        },
+        plaintext: {
+          destination: {
+            path: `${t.context.folder}/nested/plain.text`
+          }
         }
       },
       tailwind: {
@@ -178,11 +193,6 @@ test('outputs plaintext files (custom path)', async t => {
           purge: false
         }
       }
-    },
-    plaintext: {
-      destination: {
-        path: `${t.context.folder}/nested/plain.text`
-      }
     }
   })
 
@@ -199,7 +209,7 @@ test('renders plaintext string', async t => {
 })
 
 test('copies assets to destination', async t => {
-  await Maizzle.build('production', {
+  await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -220,12 +230,14 @@ 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 => {
-  await Maizzle.build('production', {
+  await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -247,13 +259,14 @@ 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 => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -281,7 +294,7 @@ test('runs the `afterBuild` event', async t => {
 })
 
 test('supports multiple asset paths', async t => {
-  await Maizzle.build('production', {
+  await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -302,13 +315,13 @@ 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 => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       templates: {
         source: 'test/stubs/breaking',
@@ -328,7 +341,7 @@ test('warns if a template cannot be rendered and `fail` option is undefined', as
 })
 
 test('warns if a template cannot be rendered and `fail` option is `verbose`', async t => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'verbose',
       templates: {
@@ -349,7 +362,7 @@ test('warns if a template cannot be rendered and `fail` option is `verbose`', as
 })
 
 test('warns if a template cannot be rendered and `fail` option is `silent`', async t => {
-  const {files} = await Maizzle.build('production', {
+  const {files} = await Maizzle.build('maizzle-ci', {
     build: {
       fail: 'silent',
       templates: {
@@ -384,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 => {
@@ -416,3 +440,72 @@ test('throws if it cannot spin up local development server', async t => {
     await Maizzle.serve('local', {})
   }, {instanceOf: TypeError})
 })
+
+test('works with templates.source defined as function (string paths)', async t => {
+  const {files} = await Maizzle.build('maizzle-ci', {
+    build: {
+      fail: 'silent',
+      templates: {
+        source: () => 'test/stubs/templates',
+        destination: {
+          path: t.context.folder
+        }
+      }
+    }
+  })
+
+  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: config => {
+          return config.build.customSources
+        },
+        destination: {
+          path: t.context.folder
+        }
+      }
+    }
+  })
+
+  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})
+})