gulp-jlto 1.2.1 → 1.3.1

package/.nvmrc

@@ -0,0 +1 @@
+v24.13.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2020 Dmytro Krekota
+Copyright (c) 2018-2026 Dmytro Krekota
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,13 +1,3 @@
-# Support Ukraine 🇺🇦
-
-- Via United24 platform (the initiative of the President of Ukraine):
-  - [One click donation (credit card, bank transfer or crypto)](https://u24.gov.ua/)
-- Via National Bank of Ukraine:
-  - [Ukrainian army](https://bank.gov.ua/en/about/support-the-armed-forces)
-  - [Humanitarian aid to Ukraine](https://bank.gov.ua/en/about/humanitarian-aid-to-ukraine)
-
-[#StandWithUkraine](https://twitter.com/hashtag/StandWithUkraine)
-
 # gulp-jlto
 
 [![NPM](https://nodei.co/npm/gulp-jlto.png?downloads=true)](https://nodei.co/npm/gulp-jlto/)
@@ -39,3 +29,15 @@ gulp.task('jlto', () => {
     .pipe(gulp.dest('build'));
 });
 ```
+
+## Tests
+
+Tests are written using Node's `assert` module. To run them, invoke `npm test`.
+
+## Further Reading
+
+[Why You Should Write Open Source Code and How It Helps Your Career](https://explainme.online/article/why-you-should-write-open-source-code-and-how-it-helps-your-career)
+
+## License
+
+JLTO is available under the [MIT license](https://opensource.org/licenses/MIT), see the LICENSE file for more information.

package/index.js

@@ -12,12 +12,13 @@ module.exports = (options) => {
     }
     let source = String(file.contents);
 
-    try {
-      let result = jlto.optimizeString(source, options);
-
-      file.contents = new Buffer(result);
-    } catch (ignored) {}
-    callback(null, file);
+    Promise.resolve()
+      .then(() => jlto.optimizeString(source, options))
+      .then((result) => {
+        file.contents = Buffer.from(result);
+      })
+      .catch(() => {})
+      .finally(() => callback(null, file));
   };
 
   return transform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gulp-jlto",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Gulp tool for optimizing Jinja like templates",
   "keywords": [
     "jinja",
@@ -31,11 +31,18 @@
     "url": "git://github.com/dmytro-krekota/gulp-jlto.git"
   },
   "main": "index.js",
-  "engines": {
-    "node": ">=12"
+  "scripts": {
+    "lint": "eslint .",
+    "test": "node test/main.test.js && node test/gulp-task.test.js"
   },
   "license": "MIT",
   "dependencies": {
-    "jlto": "^1.4.2"
+    "jlto": "^1.5.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.3",
+    "eslint": "^9.39.3",
+    "globals": "^17.3.0",
+    "gulp": "^5.0.1"
   }
 }

package/test/gulp-task.test.js

@@ -0,0 +1,153 @@
+let assert = require('assert');
+let fs = require('fs');
+let os = require('os');
+let path = require('path');
+let stream = require('stream');
+let util = require('util');
+let gulp = require('gulp');
+let jlto = require('jlto');
+let createPlugin = require('../index');
+
+let fsp = fs.promises;
+let finished = util.promisify(stream.finished);
+let originalOptimizeString = jlto.optimizeString;
+
+let removeDirectory = async (dirPath) => {
+  if (fsp.rm) {
+    await fsp.rm(dirPath, {recursive: true, force: true});
+
+    return;
+  }
+
+  await fsp.rmdir(dirPath, {recursive: true});
+};
+
+let withTempDirectory = async (prefix, fn) => {
+  let tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+
+  try {
+    await fn(tempRoot);
+  } finally {
+    await removeDirectory(tempRoot);
+  }
+};
+
+let runTask = (taskFn) => {
+  return new Promise((resolve, reject) => {
+    gulp.series(taskFn)((error) => {
+      if (error) {
+        return reject(error);
+      }
+      resolve();
+    });
+  });
+};
+
+let runTest = async (name, fn) => {
+  try {
+    jlto.optimizeString = originalOptimizeString;
+    await fn();
+    console.log('ok - ' + name);
+  } catch (error) {
+    console.error('not ok - ' + name);
+    console.error(error && error.stack ? error.stack : error);
+    process.exitCode = 1;
+  } finally {
+    jlto.optimizeString = originalOptimizeString;
+  }
+};
+
+let buildPaths = (tempRoot) => {
+  let sourceDir = path.join(tempRoot, 'src');
+  let outputDir = path.join(tempRoot, 'dist');
+  let sourceFilePath = path.join(sourceDir, 'template.html');
+  let outputFilePath = path.join(outputDir, 'template.html');
+
+  return {
+    sourceDir,
+    outputDir,
+    sourceFilePath,
+    outputFilePath,
+  };
+};
+
+let testOptimizedOutput = async () => {
+  await withTempDirectory('gulp-jlto-', async (tempRoot) => {
+    let sourceString = '{% if user %}\n  <div> Hello </div>\n{% endif %}';
+    let expectedString = '{% if user %}<div>Hello</div>{% endif %}';
+    let {sourceDir, outputDir, sourceFilePath, outputFilePath} = buildPaths(tempRoot);
+
+    await fsp.mkdir(sourceDir, {recursive: true});
+    await fsp.writeFile(sourceFilePath, sourceString, 'utf8');
+
+    jlto.optimizeString = async (source, options) => {
+      assert.strictEqual(source, sourceString);
+      assert.deepStrictEqual(options, {strip: true});
+
+      return expectedString;
+    };
+
+    let optimizeTask = () => {
+      let vinylStream = gulp
+        .src(path.join(sourceDir, '*.html'))
+        .pipe(createPlugin({strip: true}))
+        .pipe(gulp.dest(outputDir));
+
+      return finished(vinylStream);
+    };
+
+    await runTask(optimizeTask);
+
+    let output = await fsp.readFile(outputFilePath, 'utf8');
+
+    assert.strictEqual(output, expectedString);
+  });
+};
+
+let testFallbackOnOptimizeFailure = async () => {
+  await withTempDirectory('gulp-jlto-', async (tempRoot) => {
+    let sourceString = '{% if user %}\n  <div> Hello </div>\n{% endif %}';
+    let called = false;
+    let {sourceDir, outputDir, sourceFilePath, outputFilePath} = buildPaths(tempRoot);
+
+    await fsp.mkdir(sourceDir, {recursive: true});
+    await fsp.writeFile(sourceFilePath, sourceString, 'utf8');
+
+    jlto.optimizeString = async (source, options) => {
+      called = true;
+      assert.strictEqual(source, sourceString);
+      assert.strictEqual(options, undefined);
+      throw new Error('optimizer failed');
+    };
+
+    let optimizeTask = () => {
+      let vinylStream = gulp
+        .src(path.join(sourceDir, '*.html'))
+        .pipe(createPlugin())
+        .pipe(gulp.dest(outputDir));
+
+      return finished(vinylStream);
+    };
+
+    await runTask(optimizeTask);
+
+    let output = await fsp.readFile(outputFilePath, 'utf8');
+
+    assert.strictEqual(called, true);
+    assert.strictEqual(output, sourceString);
+  });
+};
+
+let run = async () => {
+  await runTest('runs plugin in a gulp task and writes optimized output', testOptimizedOutput);
+  await runTest('keeps original output in gulp task when optimizer fails', testFallbackOnOptimizeFailure);
+
+  if (process.exitCode && process.exitCode !== 0) {
+    process.exit(process.exitCode);
+  }
+};
+
+run().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/test/main.test.js

@@ -0,0 +1,115 @@
+let assert = require('assert');
+let jlto = require('jlto');
+let createPlugin = require('../index');
+
+let originalOptimizeString = jlto.optimizeString;
+
+let runPlugin = (file, options) => {
+  let plugin = createPlugin(options);
+
+  return new Promise((resolve, reject) => {
+    plugin._transform(file, 'utf8', (error, outputFile) => {
+      if (error) {
+        return reject(error);
+      }
+      resolve(outputFile);
+    });
+  });
+};
+
+let createFile = (contents) => {
+  return {
+    isNull: () => false,
+    contents: Buffer.from(contents),
+  };
+};
+
+let testCases = [
+  {
+    name: 'passes null files through unchanged',
+    run: async () => {
+      let called = false;
+
+      jlto.optimizeString = async () => {
+        called = true;
+
+        return 'ignored';
+      };
+
+      let file = {
+        isNull: () => true,
+        contents: Buffer.from('source'),
+      };
+      let result = await runPlugin(file);
+
+      assert.strictEqual(result, file);
+      assert.strictEqual(result.contents.toString(), 'source');
+      assert.strictEqual(called, false);
+    },
+  },
+  {
+    name: 'optimizes non-null files when optimizer resolves',
+    run: async () => {
+      let sourceString = '{% if user %}\n  <div> Hello </div>\n{% endif %}';
+      let expectedString = '{% if user %}<div>Hello</div>{% endif %}';
+
+      jlto.optimizeString = async (source, options) => {
+        assert.strictEqual(source, sourceString);
+        assert.deepStrictEqual(options, {keepComments: false});
+
+        return expectedString;
+      };
+
+      let file = createFile(sourceString);
+      let result = await runPlugin(file, {keepComments: false});
+
+      assert.strictEqual(result, file);
+      assert.strictEqual(result.contents.toString(), expectedString);
+    },
+  },
+  {
+    name: 'keeps original contents when optimizer throws',
+    run: async () => {
+      let called = false;
+
+      jlto.optimizeString = async () => {
+        called = true;
+        throw new Error('boom');
+      };
+
+      let file = createFile('source');
+      let result = await runPlugin(file);
+
+      assert.strictEqual(result, file);
+      assert.strictEqual(called, true);
+      assert.strictEqual(result.contents.toString(), 'source');
+    },
+  },
+];
+
+let run = async () => {
+  let failures = 0;
+
+  for (let testCase of testCases) {
+    try {
+      jlto.optimizeString = originalOptimizeString;
+      await testCase.run();
+      console.log('ok - ' + testCase.name);
+    } catch (error) {
+      failures += 1;
+      console.error('not ok - ' + testCase.name);
+      console.error(error && error.stack ? error.stack : error);
+    } finally {
+      jlto.optimizeString = originalOptimizeString;
+    }
+  }
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+};
+
+run().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});