@tiveor/scg 0.1.6 → 0.2.0

package/.prettierrc

@@ -1,13 +1,10 @@
 {
     "singleQuote": true,
     "printWidth": 80,
-    "editor.formatOnSave": true,
     "proseWrap": "always",
     "tabWidth": 2,
-    "requireConfig": false,
     "useTabs": false,
     "trailingComma": "none",
     "bracketSpacing": true,
-    "jsxBracketSameLine": false,
     "semi": true
 }

package/README.md

@@ -1,64 +1,171 @@
-SCG a Random Library for Generators<br/>
-[![Build Status](https://travis-ci.org/tiveor/scg.svg?branch=master)](https://travis-ci.org/tiveor/scg)
+# SCG - Simple Code Generator
+
 [![npm version](https://badge.fury.io/js/%40tiveor%2Fscg.svg)](https://badge.fury.io/js/%40tiveor%2Fscg)
-=============================
+
+A utility library for code generation and template processing in Node.js. Provides helpers for template rendering (EJS, Handlebars, Pug), string manipulation, file operations, command execution, and CLI parameter parsing.
 
 ## Installation
+
 ```bash
 npm install @tiveor/scg
 ```
 
-## Basic usage
+## Quick Start
+
 ```javascript
-const { StringHelper } = require('@tiveor/scg');
-const replaced = StringHelper.replace('This is a {{test}}', '{{test}}', 'joke');
-// replaced = "This is a joke"
+const {
+  StringHelper,
+  FileHelper,
+  CommandHelper,
+  ParamHelper,
+  TemplateBuilder,
+  TEMPLATE_HANDLERS
+} = require('@tiveor/scg');
 ```
 
-## TemplateBuilder usage
+## API Reference
+
+### TemplateBuilder
+
+Unified interface to render templates with EJS, Handlebars, or Pug.
+
 ```javascript
-const { TemplateBuilder, TEMPLATE_HANDLERS } = require('@tiveor/scg');
-
-const ejsBuilder = new TemplateBuilder(TEMPLATE_HANDLERS.EJS);
-ejsBuilder
-  .render('This is a <%= test %>', {
-    test: 'joke'
-  })
-  .then((replaced) => {
-    // replaced = "This is a joke"
-  });
-
-const pugBuilder = new TemplateBuilder(TEMPLATE_HANDLERS.PUG);
-pugBuilder
-  .render('This is a #{test}', {
-    test: 'joke'
-  })
-  .then((replaced) => {
-    // replaced = "This is a joke"
-  });
-
-const handlebarsBuilder = new TemplateBuilder(TEMPLATE_HANDLERS.HANDLEBARS);
-handlebarsBuilder
-  .render('This is a {{test}}', {
-    test: 'joke'
-  })
-  .then((replaced) => {
-    // replaced = "This is a joke"
-  });
+const builder = new TemplateBuilder(TEMPLATE_HANDLERS.EJS);
+
+// Render from string
+const html = await builder.render('Hello <%= name %>', { name: 'World' });
+
+// Render from file
+const page = await builder.renderFile('template.ejs', { title: 'Home' });
 ```
 
-## Example
+Available handlers: `TEMPLATE_HANDLERS.EJS`, `TEMPLATE_HANDLERS.HANDLEBARS`, `TEMPLATE_HANDLERS.PUG`
+
+#### Examples with each engine
+
+```javascript
+// EJS
+const ejs = new TemplateBuilder(TEMPLATE_HANDLERS.EJS);
+await ejs.render('Hello <%= name %>', { name: 'World' });
+
+// Handlebars
+const hbs = new TemplateBuilder(TEMPLATE_HANDLERS.HANDLEBARS);
+await hbs.render('Hello {{name}}', { name: 'World' });
+
+// Pug
+const pug = new TemplateBuilder(TEMPLATE_HANDLERS.PUG);
+await pug.render('p #{name}', { name: 'World' });
+```
+
+### StringHelper
+
+Static methods for string manipulation.
+
+```javascript
+// Replace all occurrences of a token (regex-safe)
+StringHelper.replace('Hello {{name}}!', '{{name}}', 'World');
+// => "Hello World!"
+
+// Works safely with regex special characters
+StringHelper.replace('Price: $10.00', '$10.00', '$20.00');
+// => "Price: $20.00"
+
+// Capitalize first character
+StringHelper.capitalize('hello');
+// => "Hello"
+
+// Escape regex special characters
+StringHelper.escapeRegex('$100.00 (test)');
+// => "\\$100\\.00 \\(test\\)"
+```
+
+### FileHelper
+
+Static methods for file system operations.
+
+```javascript
+// Read file to string
+const content = FileHelper.readFileToString('config.txt');
+
+// Parse JSON file to object
+const config = FileHelper.convertJsonFileToObject('config.json');
+
+// Create/remove folders
+FileHelper.createFolder('output/components');
+FileHelper.removeFolder('output/temp');
+
+// Remove file
+FileHelper.removeFile('output/old.txt');
+
+// Generate file from template with variable replacement
+await FileHelper.createFileFromFile({
+  template: 'templates/component.txt',
+  newFile: 'output/Button.tsx',
+  variables: [
+    { token: '{{name}}', value: 'Button' },
+    { token: '{{style}}', value: 'primary' }
+  ]
+});
+
+// Generate string from template
+const result = await FileHelper.createStringFromFile({
+  template: 'templates/component.txt',
+  variables: [
+    { token: '{{name}}', value: 'Button' }
+  ]
+});
+```
+
+### CommandHelper
+
+Execute shell commands as promises.
+
+```javascript
+// Run a command
+const output = await CommandHelper.run('.', 'ls -la');
+
+// Chain multiple commands
+const result = await CommandHelper.run('.', 'git add .', 'git status');
+
+// Run and clean output (strips newlines)
+const version = await CommandHelper.runClean('.', 'node --version');
+```
+
+### ParamHelper
+
+Parse CLI parameters from `process.argv`.
+
+```javascript
+// Add custom parameters
+ParamHelper.addCustomParam('--env=production');
+
+// Get parameter by index
+const script = ParamHelper.getCommandByIndex(1);
+
+// Parse all --key=value parameters
+// Example: node script.js --name=Alice --port=3000
+const params = ParamHelper.getParams();
+// => { name: "Alice", port: "3000" }
+```
+
+## Running Examples
+
 ```bash
 node example/index.js
 ```
 
-For more information about templates visit the official documentation for each one:
+## Running Tests
+
+```bash
+npm test
+```
+
+## Template Engine Documentation
 
-* EJS <br/>
-https://ejs.co/#docs
+- [EJS](https://ejs.co/#docs)
+- [Pug](https://pugjs.org/api/getting-started.html)
+- [Handlebars](https://handlebarsjs.com/guide/)
 
-* PUG <br/>
-https://pugjs.org/api/getting-started.html
+## License
 
-* Handlebars <br>
-https://handlebarsjs.com/guide/
+MIT - Alvaro Orellana - AlvaroTech.dev

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "@tiveor/scg",
-  "version": "0.1.6",
-  "description": "SCG a Random Library for Generators",
+  "version": "0.2.0",
+  "description": "Simple Code Generator - A utility library for code generation and template processing",
   "main": "index.js",
   "scripts": {
-    "test": "mocha ./test"
+    "test": "mocha ./test",
+    "example": "node example/index.js"
   },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "code-generator",
+    "template",
+    "scaffolding",
+    "ejs",
+    "handlebars",
+    "pug",
+    "file-helper",
+    "string-helper"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tiveor/scg.git"

package/src/command_helper.js

@@ -1,10 +1,16 @@
-const { exec } = require("child_process");
+const { exec } = require('child_process');
 
 class CommandHelper {
   static run(directory, ...command) {
-    return new Promise((ok, reject) => {
-      const cmd = command.join(" && ");
-      //console.log(cmd);
+    if (!directory) {
+      return Promise.reject(new Error('directory is required'));
+    }
+    if (command.length === 0) {
+      return Promise.reject(new Error('at least one command is required'));
+    }
+
+    return new Promise((resolve, reject) => {
+      const cmd = command.join(' && ');
       exec(
         cmd,
         { cwd: directory, maxBuffer: 1024 * 1024 * 100 },
@@ -15,26 +21,19 @@ class CommandHelper {
           }
 
           if (stderr) {
-            ok(stderr);
+            resolve(stderr);
             return;
           }
 
-          ok(stdout);
+          resolve(stdout);
         }
       );
-    }).catch((error) => {
-      console.log(error);
     });
   }
 
   static runClean(folder, ...command) {
-    return new Promise((ok, reject) => {
-      CommandHelper.run(folder, ...command)
-        .then((cmdRes) => {
-          const config = cmdRes && cmdRes.replace(/\r?\n|\r/g, "");
-          ok(config);
-        })
-        .catch(reject);
+    return CommandHelper.run(folder, ...command).then((result) => {
+      return result && result.replace(/\r?\n|\r/g, '');
     });
   }
 }

package/src/file_helper.js

@@ -1,7 +1,7 @@
-const fs = require("fs");
-const readline = require("readline");
-const { StringHelper } = require("./string_helper");
-const { CommandHelper } = require("./command_helper");
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { StringHelper } = require('./string_helper');
 
 class FileHelper {
   static readFileToString(fileName) {
@@ -18,7 +18,7 @@ class FileHelper {
   }
 
   static async dynamicReplace(replacement) {
-    let res = "";
+    let res = '';
     for (let v in replacement.variables) {
       const properties = replacement.variables[v];
       await FileHelper.readLineByLine(replacement.template, (line) => {
@@ -43,7 +43,7 @@ class FileHelper {
     await FileHelper.readLineByLine(template, async (line) => {
       let newLine = StringHelper.replace(
         line,
-        "@date",
+        '@date',
         new Date().toUTCString()
       );
 
@@ -52,7 +52,6 @@ class FileHelper {
 
         if (newLine.indexOf(replacement.token) > 0) {
           if (replacement.template) {
-            //dynamic since there is no value
             newLine = await FileHelper.dynamicReplace(replacement);
             break;
           } else if (replacement.value) {
@@ -67,12 +66,12 @@ class FileHelper {
   }
 
   static async createStringFromFile({ template, variables }) {
-    let res = "";
+    let res = '';
 
     await FileHelper.readLineByLine(template, async (line) => {
       let newLine = StringHelper.replace(
         line,
-        "@date",
+        '@date',
         new Date().toUTCString()
       );
 
@@ -81,7 +80,6 @@ class FileHelper {
 
         if (newLine.indexOf(replacement.token) > 0) {
           if (replacement.template) {
-            //dynamic since there is no value
             newLine = await FileHelper.dynamicReplace(replacement);
             break;
           } else if (replacement.value) {
@@ -89,31 +87,27 @@ class FileHelper {
           }
         }
       }
-      res += newLine + "\n";
+      res += newLine + '\n';
     });
     return res;
   }
 
-  static async readLineByLine(fileName, newLine) {
+  static async readLineByLine(fileName, callback) {
     const fileStream = fs.createReadStream(fileName);
 
     const rl = readline.createInterface({
       input: fileStream,
-      crlfDelay: Infinity,
+      crlfDelay: Infinity
     });
 
-    let index = 0;
-
     for await (const line of rl) {
-      index++;
-      //console.log(index);
-      await newLine(line);
+      await callback(line);
     }
   }
 
   static writer(filename) {
     return fs.createWriteStream(filename, {
-      flags: "a",
+      flags: 'a'
     });
   }
 
@@ -122,20 +116,24 @@ class FileHelper {
   }
 
   static createFolder(folderName) {
-    !fs.existsSync(`./${folderName}/`) &&
-      fs.mkdirSync(`./${folderName}/`, { recursive: true });
+    const resolved = path.resolve(folderName);
+    if (!fs.existsSync(resolved)) {
+      fs.mkdirSync(resolved, { recursive: true });
+    }
   }
 
   static removeFolder(folderName) {
-    return CommandHelper.runClean(
-      ".",
-      `rm -Rf '${folderName}'`);
+    const resolved = path.resolve(folderName);
+    if (fs.existsSync(resolved)) {
+      fs.rmSync(resolved, { recursive: true, force: true });
+    }
   }
 
   static removeFile(filename) {
-    return CommandHelper.runClean(
-      ".",
-      `rm -f '${filename}'`);
+    const resolved = path.resolve(filename);
+    if (fs.existsSync(resolved)) {
+      fs.rmSync(resolved, { force: true });
+    }
   }
 }
 

package/src/string_helper.js

@@ -1,10 +1,16 @@
 class StringHelper {
+  static escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
   static replace(line, token, value) {
-    return line.replace(new RegExp(token, "g"), value);
+    if (typeof line !== 'string') return '';
+    if (typeof token !== 'string') return line;
+    return line.replace(new RegExp(StringHelper.escapeRegex(token), 'g'), value);
   }
 
   static capitalize(s) {
-    if (typeof s !== "string") return "";
+    if (typeof s !== 'string') return '';
     return s.charAt(0).toUpperCase() + s.slice(1);
   }
 }

package/src/template_builder.js

@@ -15,7 +15,7 @@ class TemplateBuilder {
       case TEMPLATE_HANDLERS.EJS:
         return EjsHelper.render(source, data, options);
       case TEMPLATE_HANDLERS.PUG:
-        return PugHelper.render(fileName, data, options);
+        return PugHelper.render(source, data, options);
       default:
         return HandlebarsHelper.render(source, data, options);
     }

package/src/template_handlers.js

@@ -4,4 +4,4 @@ const TEMPLATE_HANDLERS = {
   PUG: 'PUG'
 };
 
-exports.TEMPLATE_HANDLERS = TEMPLATE_HANDLERS;
+module.exports = TEMPLATE_HANDLERS;

package/test/test.js

@@ -1,11 +1,394 @@
 var assert = require('assert');
-const { StringHelper } = require("../src/string_helper");
+var path = require('path');
+var fs = require('fs');
+var os = require('os');
 
-describe("StringHelper", () => {
-  describe("replace", () => {
+var { StringHelper } = require('../src/string_helper');
+var { FileHelper } = require('../src/file_helper');
+var { CommandHelper } = require('../src/command_helper');
+var { ParamHelper } = require('../src/param_helper');
+var { TemplateBuilder } = require('../src/template_builder');
+var TEMPLATE_HANDLERS = require('../src/template_handlers');
+
+// Helper to get absolute paths for example templates
+var exampleDir = path.join(__dirname, '..', 'example');
+
+describe('StringHelper', function () {
+  describe('replace', function () {
     it('should search and replace the test param', function () {
-      const replaced = StringHelper.replace("This is a {{test}}", "{{test}}", "joke");
-      assert.strictEqual(replaced, "This is a joke");
+      var replaced = StringHelper.replace(
+        'This is a {{test}}',
+        '{{test}}',
+        'joke'
+      );
+      assert.strictEqual(replaced, 'This is a joke');
+    });
+
+    it('should replace all occurrences', function () {
+      var replaced = StringHelper.replace(
+        '{{name}} likes {{name}}',
+        '{{name}}',
+        'Alice'
+      );
+      assert.strictEqual(replaced, 'Alice likes Alice');
+    });
+
+    it('should handle tokens with regex special characters', function () {
+      var replaced = StringHelper.replace(
+        'Price is $100.00 total',
+        '$100.00',
+        '$200.00'
+      );
+      assert.strictEqual(replaced, 'Price is $200.00 total');
+    });
+
+    it('should return empty string for non-string line', function () {
+      assert.strictEqual(StringHelper.replace(null, 'a', 'b'), '');
+      assert.strictEqual(StringHelper.replace(undefined, 'a', 'b'), '');
+      assert.strictEqual(StringHelper.replace(123, 'a', 'b'), '');
+    });
+
+    it('should return line unchanged for non-string token', function () {
+      assert.strictEqual(StringHelper.replace('hello', null, 'b'), 'hello');
+    });
+  });
+
+  describe('escapeRegex', function () {
+    it('should escape regex special characters', function () {
+      var escaped = StringHelper.escapeRegex('$100.00 (test)');
+      assert.strictEqual(escaped, '\\$100\\.00 \\(test\\)');
+    });
+  });
+
+  describe('capitalize', function () {
+    it('should capitalize first character', function () {
+      assert.strictEqual(StringHelper.capitalize('hello'), 'Hello');
+    });
+
+    it('should return empty string for non-string', function () {
+      assert.strictEqual(StringHelper.capitalize(123), '');
+      assert.strictEqual(StringHelper.capitalize(null), '');
+    });
+
+    it('should handle empty string', function () {
+      assert.strictEqual(StringHelper.capitalize(''), '');
+    });
+
+    it('should handle single character', function () {
+      assert.strictEqual(StringHelper.capitalize('a'), 'A');
+    });
+  });
+});
+
+describe('FileHelper', function () {
+  var tmpDir;
+
+  beforeEach(function () {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'scg-test-'));
+  });
+
+  afterEach(function () {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('readFileToString', function () {
+    it('should read a file and return its content as string', function () {
+      var filePath = path.join(tmpDir, 'test.txt');
+      fs.writeFileSync(filePath, 'hello world');
+      var content = FileHelper.readFileToString(filePath);
+      assert.strictEqual(content, 'hello world');
+    });
+  });
+
+  describe('convertJsonFileToObject', function () {
+    it('should parse a JSON file to an object', function () {
+      var filePath = path.join(tmpDir, 'test.json');
+      fs.writeFileSync(filePath, '{"name": "scg", "version": 1}');
+      var obj = FileHelper.convertJsonFileToObject(filePath);
+      assert.strictEqual(obj.name, 'scg');
+      assert.strictEqual(obj.version, 1);
+    });
+  });
+
+  describe('createFolder', function () {
+    it('should create a folder', function () {
+      var folderPath = path.join(tmpDir, 'new-folder');
+      FileHelper.createFolder(folderPath);
+      assert.ok(fs.existsSync(folderPath));
+    });
+
+    it('should create nested folders', function () {
+      var folderPath = path.join(tmpDir, 'a', 'b', 'c');
+      FileHelper.createFolder(folderPath);
+      assert.ok(fs.existsSync(folderPath));
+    });
+
+    it('should not throw if folder already exists', function () {
+      var folderPath = path.join(tmpDir, 'existing');
+      fs.mkdirSync(folderPath);
+      assert.doesNotThrow(function () {
+        FileHelper.createFolder(folderPath);
+      });
     });
-  })
-});
+  });
+
+  describe('removeFolder', function () {
+    it('should remove a folder', function () {
+      var folderPath = path.join(tmpDir, 'to-remove');
+      fs.mkdirSync(folderPath);
+      FileHelper.removeFolder(folderPath);
+      assert.ok(!fs.existsSync(folderPath));
+    });
+
+    it('should not throw if folder does not exist', function () {
+      assert.doesNotThrow(function () {
+        FileHelper.removeFolder(path.join(tmpDir, 'nonexistent'));
+      });
+    });
+  });
+
+  describe('removeFile', function () {
+    it('should remove a file', function () {
+      var filePath = path.join(tmpDir, 'to-remove.txt');
+      fs.writeFileSync(filePath, 'delete me');
+      FileHelper.removeFile(filePath);
+      assert.ok(!fs.existsSync(filePath));
+    });
+
+    it('should not throw if file does not exist', function () {
+      assert.doesNotThrow(function () {
+        FileHelper.removeFile(path.join(tmpDir, 'nonexistent.txt'));
+      });
+    });
+  });
+
+  describe('simpleReplace', function () {
+    it('should replace token with value', function () {
+      var result = FileHelper.simpleReplace('Hello {{name}}', {
+        token: '{{name}}',
+        value: 'World'
+      });
+      assert.strictEqual(result, 'Hello World');
+    });
+  });
+});
+
+describe('CommandHelper', function () {
+  describe('run', function () {
+    it('should execute a command and return stdout', function () {
+      return CommandHelper.run('.', 'echo hello').then(function (result) {
+        assert.strictEqual(result.trim(), 'hello');
+      });
+    });
+
+    it('should reject when directory is missing', function () {
+      return CommandHelper.run(null, 'echo hello').then(
+        function () {
+          assert.fail('should have rejected');
+        },
+        function (err) {
+          assert.ok(err.message.includes('directory is required'));
+        }
+      );
+    });
+
+    it('should reject when no command is given', function () {
+      return CommandHelper.run('.').then(
+        function () {
+          assert.fail('should have rejected');
+        },
+        function (err) {
+          assert.ok(err.message.includes('at least one command is required'));
+        }
+      );
+    });
+
+    it('should reject on invalid command', function () {
+      return CommandHelper.run('.', 'nonexistent_command_xyz').then(
+        function () {
+          assert.fail('should have rejected');
+        },
+        function (err) {
+          assert.ok(err);
+        }
+      );
+    });
+
+    it('should chain multiple commands', function () {
+      return CommandHelper.run('.', 'echo hello', 'echo world').then(
+        function (result) {
+          assert.ok(result.includes('hello'));
+          assert.ok(result.includes('world'));
+        }
+      );
+    });
+  });
+
+  describe('runClean', function () {
+    it('should return output without newlines', function () {
+      return CommandHelper.runClean('.', 'echo hello').then(function (result) {
+        assert.strictEqual(result, 'hello');
+      });
+    });
+  });
+});
+
+describe('ParamHelper', function () {
+  var originalArgv;
+
+  beforeEach(function () {
+    originalArgv = process.argv.slice();
+  });
+
+  afterEach(function () {
+    process.argv = originalArgv;
+  });
+
+  describe('addCustomParam', function () {
+    it('should add a parameter to process.argv', function () {
+      var before = process.argv.length;
+      ParamHelper.addCustomParam('--test=123');
+      assert.strictEqual(process.argv.length, before + 1);
+      assert.strictEqual(process.argv[process.argv.length - 1], '--test=123');
+    });
+  });
+
+  describe('getCommandByIndex', function () {
+    it('should return argv value at index', function () {
+      var result = ParamHelper.getCommandByIndex(0);
+      assert.strictEqual(result, process.argv[0]);
+    });
+
+    it('should return empty string for out-of-bounds index', function () {
+      var result = ParamHelper.getCommandByIndex(9999);
+      assert.strictEqual(result, '');
+    });
+  });
+
+  describe('getParams', function () {
+    it('should parse --key=value params', function () {
+      process.argv = ['node', 'test', '--name=Alice', '--age=30'];
+      var params = ParamHelper.getParams();
+      assert.strictEqual(params.name, 'Alice');
+      assert.strictEqual(params.age, '30');
+    });
+
+    it('should strip quotes from values', function () {
+      process.argv = ['node', 'test', '--name="Alice"', "--city='Paris'"];
+      var params = ParamHelper.getParams();
+      assert.strictEqual(params.name, 'Alice');
+      assert.strictEqual(params.city, 'Paris');
+    });
+
+    it('should return empty object when no params', function () {
+      process.argv = ['node', 'test'];
+      var params = ParamHelper.getParams();
+      assert.deepStrictEqual(params, {});
+    });
+  });
+});
+
+describe('TemplateBuilder', function () {
+  describe('render (from string)', function () {
+    it('should render EJS template from string', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.EJS);
+      return builder
+        .render('Hello <%= name %>', { name: 'World' })
+        .then(function (result) {
+          assert.strictEqual(result, 'Hello World');
+        });
+    });
+
+    it('should render Handlebars template from string', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.HANDLEBARS);
+      return builder
+        .render('Hello {{name}}', { name: 'World' })
+        .then(function (result) {
+          assert.strictEqual(result, 'Hello World');
+        });
+    });
+
+    it('should render Pug template from string', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.PUG);
+      return builder
+        .render('p #{name}', { name: 'World' })
+        .then(function (result) {
+          assert.strictEqual(result, '<p>World</p>');
+        });
+    });
+
+    it('should default to Handlebars for unknown handler', function () {
+      var builder = new TemplateBuilder('UNKNOWN');
+      return builder
+        .render('Hello {{name}}', { name: 'World' })
+        .then(function (result) {
+          assert.strictEqual(result, 'Hello World');
+        });
+    });
+  });
+
+  describe('renderFile', function () {
+    it('should render EJS template from file', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.EJS);
+      return builder
+        .renderFile(
+          path.join(exampleDir, 'ejs', 'hello.ejs'),
+          { title: 'Test', body: 'Body' },
+          {}
+        )
+        .then(function (result) {
+          assert.ok(result.includes('Test'));
+          assert.ok(result.includes('Body'));
+        });
+    });
+
+    it('should render Handlebars template from file', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.HANDLEBARS);
+      return builder
+        .renderFile(
+          path.join(exampleDir, 'handlebars', 'hello.handlebars'),
+          { title: 'Test', body: 'Body' },
+          {}
+        )
+        .then(function (result) {
+          assert.ok(result.includes('Test'));
+          assert.ok(result.includes('Body'));
+        });
+    });
+
+    it('should render Pug template from file', function () {
+      var builder = new TemplateBuilder(TEMPLATE_HANDLERS.PUG);
+      return builder
+        .renderFile(
+          path.join(exampleDir, 'pug', 'hello.pug'),
+          { title: 'Test', body: 'Body' },
+          {}
+        )
+        .then(function (result) {
+          assert.ok(result.includes('Test'));
+          assert.ok(result.includes('Body'));
+        });
+    });
+  });
+});
+
+describe('TEMPLATE_HANDLERS', function () {
+  it('should export HANDLEBARS, EJS, and PUG', function () {
+    assert.strictEqual(TEMPLATE_HANDLERS.HANDLEBARS, 'HANDLEBARS');
+    assert.strictEqual(TEMPLATE_HANDLERS.EJS, 'EJS');
+    assert.strictEqual(TEMPLATE_HANDLERS.PUG, 'PUG');
+  });
+});
+
+describe('index (main exports)', function () {
+  var scg = require('../index');
+
+  it('should export all modules', function () {
+    assert.ok(scg.StringHelper);
+    assert.ok(scg.FileHelper);
+    assert.ok(scg.CommandHelper);
+    assert.ok(scg.ParamHelper);
+    assert.ok(scg.TemplateBuilder);
+    assert.ok(scg.TEMPLATE_HANDLERS);
+  });
+});

package/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-  "emmet.includeLanguages": {
-    "ejs": "html"
-  }
-}