v1.0.1

Merge pull request #24 from chenasraf/alpha

.github/workflows/alpha.yml

@@ -13,8 +13,12 @@ jobs:
         with:
           node-version: "12.x"
       - run: yarn install --frozen-lockfile
-      - run: yarn pack --filename=release.tgz
+      - run: yarn test
+      - run: yarn build
+      - run: cd ./dist && yarn pack --filename=../package.tgz
+        if: "!contains(github.event.head_commit.message, '[skip publish]')"
       - uses: Klemensas/action-autotag@stable
+        if: "!contains(github.event.head_commit.message, '[skip publish]')"
         id: update_tag
         with:
           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
@@ -26,16 +30,17 @@ jobs:
           package: ./dist/package.json
           token: "${{ secrets.NPM_TOKEN }}"
       - name: Create Release
-        if: "steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')"
+        if: steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')
         uses: actions/create-release@v1
         id: create_release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
+          prerelease: true
           tag_name: ${{ steps.update_tag.outputs.tagname }}
           release_name: Release ${{ steps.update_tag.outputs.tagname }}
       - name: Upload Release Asset
-        if: "steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')"
+        if: steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')
         id: upload-release-asset
         uses: actions/upload-release-asset@v1
         env:
@@ -43,5 +48,5 @@ jobs:
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
           asset_path: ./package.tgz
-          asset_name: package.tgz
+          asset_name: simple-scaffold ${{ steps.update_tag.outputs.tagname }}.tgz
           asset_content_type: application/tgz

.github/workflows/main.yml

@@ -13,8 +13,12 @@ jobs:
         with:
           node-version: "12.x"
       - run: yarn install --frozen-lockfile
-      - run: yarn pack --filename=release.tgz
+      - run: yarn test
+      - run: yarn build
+      - run: cd ./dist && yarn pack --filename=../package.tgz
+        if: "!contains(github.event.head_commit.message, '[skip publish]')"
       - uses: Klemensas/action-autotag@stable
+        if: "!contains(github.event.head_commit.message, '[skip publish]')"
         id: update_tag
         with:
           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
@@ -22,10 +26,10 @@ jobs:
       - name: Publish on NPM
         uses: JS-DevTools/npm-publish@v1
         with:
-          package: dist/package.json
+          package: ./dist/package.json
           token: "${{ secrets.NPM_TOKEN }}"
       - name: Create Release
-        if: steps.update_tag.outputs.tagname
+        if: steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')
         uses: actions/create-release@v1
         id: create_release
         env:
@@ -34,7 +38,7 @@ jobs:
           tag_name: ${{ steps.update_tag.outputs.tagname }}
           release_name: Release ${{ steps.update_tag.outputs.tagname }}
       - name: Upload Release Asset
-        if: steps.update_tag.outputs.tagname
+        if: steps.update_tag.outputs.tagname && !contains(github.event.head_commit.message, '[skip publish]')
         id: upload-release-asset
         uses: actions/upload-release-asset@v1
         env:
@@ -42,5 +46,5 @@ jobs:
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
           asset_path: ./package.tgz
-          asset_name: package.tgz
+          asset_name: simple-scaffold ${{ steps.update_tag.outputs.tagname }}.tgz
           asset_content_type: application/tgz

.gitignore

@@ -59,3 +59,5 @@ typings/
 
 examples/test-output/**/*
 dist/
+.DS_Store
+tmp/

.vscode/settings.json

@@ -2,6 +2,12 @@
   "typescript.tsdk": "./node_modules/typescript/lib",
   "npm.packageManager": "yarn",
   "cSpell.words": [
-    "massarg"
+    "massarg",
+    "nobrace",
+    "nocomment",
+    "nodir",
+    "noext",
+    "nonegate",
+    "subdir"
   ]
 }

MIGRATION.md

@@ -0,0 +1,21 @@
+# Migrating from 0.x to 1.0
+
+In Simple Scaffold v1.0, the entire codebase was overhauled, yet usage remains mostly the same
+between versions. With these notable exceptions:
+
+- Some of the argument names have changed
+- Template syntax has been improved
+- The command to run Scaffold has been simplified from `new SimpleScaffold(opts).run()` to `SimpleScaffold(opts)`, which now returns a promise that you can await to know when the process has been completed.
+
+## Argument changes
+
+- `locals` has been renamed to `data`. The appropriate command line args have been updated as
+  well to `--data` | `-d`.
+
+## Template syntax changes
+
+Simple Scaffold still uses Handlebars.js to handle template content and file names. However, helpers
+have been added to remove the need for you to pre-process the template data on simple use-cases such
+as case type manipulation (converting to camel case, snake case, etc)
+
+See the readme for the full information on how to use these helpers and which are available.

README.md

@@ -2,6 +2,16 @@
 
 Simple Scaffold allows you to create your structured files based on templates.
 
+Simply organize your commonly-created files in their original structure, and replace any variable
+values (such as component or app name) inside the paths or contents of the files with tokens to be
+populated upon scaffolding.
+
+Then, run Simple Scaffold and it will generate your files for you in the desired structure,
+with file names and contents that contain your dynamic information.
+
+It's a simple way to easily create reusable components, common class files to start writing from,
+or even entire app structures.
+
 ## Install
 
 You can either use it as a command line tool or import into your own code and run from there.
@@ -22,43 +32,58 @@ npx simple-scaffold <...args>
 ```plaintext
 Usage: simple-scaffold [options]
 
+Create structured files based on templates.
+
 Options:
 
-  --help|-h                 Display help information
+  --help|-h                       Display help information
 
-  --name|-n                 Name to be passed to the generated files. {{name}} and
-                            {{Name}} inside contents and file names will be replaced
-                            accordingly.
+  --name|-n                       Name to be passed to the generated files. {{name}} and
+                                  {{Name}} inside contents and file names will be replaced
+                                  accordingly.
 
-  --output|-o               Path to output to. If --create-sub-folder is enabled, the
-                            subfolder will be created inside this path.
+  --output|-o                     Path to output to. If --create-sub-folder is enabled,
+                                  the subfolder will be created inside this path.
+                                  (default: current dir)
 
-  --templates|-t            Template files to use as input. You may provide multiple
-                            files, each of which can be a relative or absolute path, or a glob
-                            pattern for multiple file matching easily.
+  --templates|-t                  Template files to use as input. You may provide multiple
+                                  files, each of which can be a relative or absolute path, or a
+                                  glob pattern for multiple file matching easily.
 
-  --overwrite|-w            Enable to override output files, even if they already exist.
-                            (default: false)
+  --overwrite|-w                  Enable to override output files, even if they already
+                                  exist. (default: false)
 
-  --data|-d                 Add custom data to the templates. By default, only your app
-                            name is included.
+  --data|-d                       Add custom data to the templates. By default, only your
+                                  app name is included.
 
-  --create-sub-folder|-s    Create subfolder with the input name (default:
-                            false)
+  --create-sub-folder|-s          Create subfolder with the input name
+                                  (default: false)
 
-  --quiet|-q                Suppress output logs (default:
-                            false)
+  --sub-folder-name-helper|-sh    Default helper to apply to subfolder name when using
+                                  `--create-sub-folder true`.
 
-  --dry-run|-dr             Don't emit actual files. This is good for testing your
-                            scaffolds and making sure they don't fail, without having to write
-                            actual files. (default: false)
+  --quiet|-q                      Suppress output logs (Same as --verbose 0)
+                                  (default: false)
+
+  --verbose|-v                    Determine amount of logs to display. The values are:
+                                  0 (none) | 1 (debug) | 2 (info) | 3 (warn) | 4
+                                  (error). The provided level will display messages of
+                                  the same level or higher. (default:
+                                  2)
+
+  --dry-run|-dr                   Don't emit files. This is good for testing your
+                                  scaffolds and making sure they don't fail, without having to
+                                  write actual file contents or create directories.
+                                  (default: false)
 ```
 
 You can also add this as a script in your `package.json`:
 
 ```json
 {
+  ...
   "scripts": {
+    ...
     "scaffold": "yarn simple-scaffold --templates scaffolds/component/**/* --output src/components --data '{\"myProp\": \"propName\", \"myVal\": \"123\"}'"
   }
 }
@@ -67,33 +92,48 @@ You can also add this as a script in your `package.json`:
 ## Use in Node.js
 
 You can also build the scaffold yourself, if you want to create more complex arguments or scaffold groups.
-Simply pass a config object to the constructor, and invoke `run()` when you are ready to start.
+Simply pass a config object to the Scaffold function when you are ready to start.
 The config takes similar arguments to the command line:
 
-```javascript
-const SimpleScaffold = require("simple-scaffold").default
+```typescript
+import Scaffold from "simple-scaffold"
 
-const scaffold = new SimpleScaffold({
+const config = {
   name: "component",
   templates: [path.join(__dirname, "scaffolds", "component")],
   output: path.join(__dirname, "src", "components"),
   createSubFolder: true,
+  subFolderNameHelper: "upperCase"
   locals: {
     property: "value",
   },
-}).run()
-```
-
-The exception in the config is that `output`, when used in Node directly, may also be passed a
-function for each input file to output into a dynamic path:
-
-```javascript
-config.output = (fullPath, baseDir, baseName) => {
-  console.log({ fullPath, baseDir, baseName })
-  return [baseDir, baseName].join(path.sep)
+  helpers: {
+    twice: (text) => [text, text].join(" ")
+  }
 }
+
+const scaffold = Scaffold(config)
 ```
 
+### Additional Node.js options
+
+In addition to all the options available in the command line, there are some JS-specific options
+available:
+
+1. When `output` is used in Node directly, it may also be passed a function for each input file to
+   output into a dynamic path:
+
+    ```typescript
+    config.output = (fullPath, baseDir, baseName) => {
+      console.log({ fullPath, baseDir, baseName })
+      return path.resolve(baseDir, baseName)
+    }
+    ```
+
+2. You may add custom `helpers` to your scaffolds. Helpers are simple `(string) => string` functions
+   that transform your `data` variables into other values. See [Helpers](#helpers) for the list of
+   default helpers, or add your own to be loaded into the template parser.
+
 ## Preparing files
 
 ### Template files
@@ -118,23 +158,40 @@ Your `data` will be pre-populated with the following:
 > Any `data` you add in the config will be available for use with their names wrapped in
 > `{{` and `}}`.
 
+#### Helpers
+
 Simple-Scaffold provides some built-in text transformation filters usable by handleBars.
 
-For example, you may use `{{ name | snakeCase }}` inside a template file or filename, and it will
+For example, you may use `{{ snakeCase name }}` inside a template file or filename, and it will
 replace `My Name` with `my_name` when producing the final value.
 
 Here are the built-in helpers available for use:
 
-```plaintext
-{{ name | camelCase }}    =>    myName
-{{ name | snakeCase }}    =>    my_name
-{{ name | startCase }}    =>    My Name
-{{ name | kebabCase }}    =>    my-name
-{{ name | hyphenCase }}   =>    my-name
-{{ name | pascalCase }}   =>    MyName
+| Helper name | Example code            | Example output |
+| ----------- | ----------------------- | -------------- |
+| camelCase   | `{{ camelCase name }}`  | myName         |
+| snakeCase   | `{{ snakeCase name }}`  | my_name        |
+| startCase   | `{{ startCase name }}`  | My Name        |
+| kebabCase   | `{{ kebabCase name }}`  | my-name        |
+| hyphenCase  | `{{ hyphenCase name }}` | my-name        |
+| pascalCase  | `{{ pascalCase name }}` | MyName         |
+| upperCase   | `{{ upperCase name }}`  | MYNAME         |
+| lowerCase   | `{{ lowerCase name }}`  | myname         |
+
+> These helpers are available for any data property, not exclusive to `name`.
+
+You may also add your own custom helpers using the `helpers` options when using the JS API (rather
+than the CLI). The `helpers` option takes an object whose keys are helper names, and values are
+the transformation functions. For example, `upperCase` is implemented like so:
+
+```typescript
+config.helpers = {
+  upperCase: (text) => text.toUpperCase(),
+}
 ```
 
-**Note:** These helpers are available for any data property, not exclusive to `name`.
+These helpers will also be available to you when using `subFolderNameHelper` or
+`--sub-folder-name-helper` as a possible value.
 
 ## Examples
 
@@ -144,7 +201,8 @@ Here are the built-in helpers available for use:
 simple-scaffold MyComponent \
     -t project/scaffold/**/* \
     -o src/components \
-    -d '{"className":"myClassName"}'
+    -d '{"className": "myClassName"}'
+    MyComponent
 ```
 
 ### Example Scaffold Input
@@ -160,15 +218,15 @@ simple-scaffold MyComponent \
     - ...
 ```
 
-#### Contents of `project/scaffold/{{Name}}.js`
+#### Contents of `project/scaffold/{{Name}}.jsx`
 
 ```js
 const React = require('react')
 
-module.exports = class {{Name}} extends React.Component {
-  render() {
+module.exports = function {{Name}}(props) {
+  return (
     <div className="{{className}}">{{Name}} Component</div>
-  }
+  )
 }
 ```
 
@@ -185,7 +243,7 @@ module.exports = class {{Name}} extends React.Component {
     - ...
 ```
 
-With `createSubfolder = false`:
+With `createSubFolder = false`:
 
 ```plaintext
 - project
@@ -195,14 +253,42 @@ With `createSubfolder = false`:
     - ...
 ```
 
-#### Contents of `project/scaffold/MyComponent/MyComponent.js`
+#### Contents of `project/scaffold/MyComponent/MyComponent.jsx`
 
 ```js
 const React = require("react")
 
-module.exports = class MyComponent extends React.Component {
-  render() {
-    <div className="my-component">MyComponent Component</div>
-  }
+module.exports = function MyComponent(props) {
+  return (
+    <div className="myClassName">MyComponent Component</div>
+  )
 }
 ```
+
+## Contributing
+
+I welcome any issues or pull requests on GitHub. If you find a bug, or would like a new feature,
+don't hesitate to open an appropriate issue and I will do my best to reply promptly.
+
+If you are a developer and want to contribute code, here are some starting tips:
+
+1. Fork this repository
+2. Run `yarn install`
+3. Run `yarn dev` to start file watch mode
+4. Make any changes you would like
+5. Create tests for your changes
+6. Update the relevant documentation (readme, code comments, type comments)
+7. Create a PR on upstream
+
+Some tips on getting around the code:
+
+- Use `yarn dev` for development - it runs TypeScript compile in watch mode, allowing you to make
+  changes and immediately be able to try them using `yarn cmd`.
+- Use `yarn build` to build the output
+- Use `yarn test` to run tests
+- Use `yarn cmd` to use the CLI feature of Simple Scaffold from within the root directory,
+  enabling you to test different behaviors. See `yarn cmd -h` for more information.
+
+  > This requires an updated build, and does not trigger one itself. Either use `yarn dev` to watch
+  > for changes and build, or `yarn build` before running this, or use `yarn build-cmd` instead, 
+  > which triggers a build right before running the command with the rest of the given arguments.

package.json

@@ -1,16 +1,15 @@
 {
   "name": "simple-scaffold",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.1",
   "description": "Create files based on templates",
   "repository": "https://github.com/chenasraf/simple-scaffold.git",
   "author": "Chen Asraf <inbox@casraf.com>",
   "license": "MIT",
   "main": "index.js",
   "bin": "cmd.js",
-  "types": "index.d.ts",
   "scripts": {
     "clean": "rm -rf dist/",
-    "build": "yarn clean && tsc && chmod -R +x ./dist && cp ./package.json ./dist/package.json",
+    "build": "yarn clean && tsc && chmod -R +x ./dist && cp ./package.json ./README.md ./dist/",
     "dev": "tsc --watch",
     "start": "node dist/scaffold.js",
     "test": "jest --verbose",
@@ -20,10 +19,11 @@
   },
   "dependencies": {
     "args": "^5.0.1",
+    "chalk": "^4.1.2",
     "glob": "^7.1.3",
     "handlebars": "^4.7.7",
     "lodash": "^4.17.21",
-    "massarg": "^0.1.2",
+    "massarg": "^1.0.5",
     "util.promisify": "^1.1.1"
   },
   "devDependencies": {

src/cmd.ts

@@ -1,69 +1,102 @@
-import Scaffold from "./scaffold"
+#!/usr/bin/env node
 import massarg from "massarg"
-import { ScaffoldCmdConfig } from "./types"
+import chalk from "chalk"
+import { LogLevel, ScaffoldCmdConfig } from "./types"
+import { Scaffold } from "./scaffold"
 
-massarg<ScaffoldCmdConfig & { help: boolean; extras: string[] }>()
-  .main(Scaffold)
-  .option({
-    name: "name",
-    aliases: ["n"],
-    isDefault: true,
-    description:
-      "Name to be passed to the generated files. {{name}} and {{Name}} inside contents and file names will be replaced accordingly.",
-  })
-  .option({
-    name: "output",
-    aliases: ["o"],
-    description:
-      "Path to output to. If --create-sub-folder is enabled, the subfolder will be created inside this path.",
-  })
-  .option({
-    name: "templates",
-    aliases: ["t"],
-    description:
-      "Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path, " +
-      "or a glob pattern for multiple file matching easily.",
-    defaultValue: [],
-    array: true,
-  })
-  .option({
-    aliases: ["w"],
-    name: "overwrite",
-    description: "Enable to override output files, even if they already exist.",
-    defaultValue: false,
-    boolean: true,
-  })
-  .option({
-    aliases: ["d"],
-    name: "data",
-    description: "Add custom data to the templates. By default, only your app name is included.",
-    parse: (v) => JSON.parse(v),
-  })
-  .option({
-    aliases: ["s"],
-    name: "create-sub-folder",
-    description: "Create subfolder with the input name",
-    defaultValue: false,
-    boolean: true,
-  })
-  .option({ aliases: ["q"], name: "quiet", description: "Suppress output logs", defaultValue: false, boolean: true })
-  .option({
-    aliases: ["dr"],
-    name: "dry-run",
-    description:
-      "Don't emit files. This is good for testing your scaffolds and making sure they " +
-      "don't fail, without having to write actual file contents or create directories.",
-    defaultValue: false,
-    boolean: true,
-  })
-  // .example({
-  //   input: `yarn cmd -t examples/test-input/Component -o examples/test-output -d '{"property":"myProp","value":"10"}'`,
-  //   description: "Usage",
-  //   output: "",
-  // })
-  .help({
-    binName: "simple-scaffold",
-    useGlobalColumns: true,
-    usageExample: "[options]",
-  })
-  .parse()
+export function parseCliArgs(args = process.argv.slice(2)) {
+  return (
+    massarg<ScaffoldCmdConfig & { help: boolean; extras: string[] }>()
+      .main(Scaffold)
+      .option({
+        name: "name",
+        aliases: ["n"],
+        description:
+          "Name to be passed to the generated files. {{name}} and {{Name}} inside contents and file names will be replaced accordingly.",
+        isDefault: true,
+        required: true,
+      })
+      .option({
+        name: "output",
+        aliases: ["o"],
+        description: `Path to output to. If --create-sub-folder is enabled, the subfolder will be created inside this path. ${chalk.reset`${chalk.white`(default: current dir)`}`}`,
+        required: true,
+      })
+      .option({
+        name: "templates",
+        aliases: ["t"],
+        array: true,
+        description:
+          "Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path, " +
+          "or a glob pattern for multiple file matching easily.",
+        required: true,
+      })
+      .option({
+        name: "overwrite",
+        aliases: ["w"],
+        boolean: true,
+        defaultValue: false,
+        description: "Enable to override output files, even if they already exist.",
+      })
+      .option({
+        name: "data",
+        aliases: ["d"],
+        description: "Add custom data to the templates. By default, only your app name is included.",
+        parse: (v) => JSON.parse(v),
+      })
+      .option({
+        name: "create-sub-folder",
+        aliases: ["s"],
+        boolean: true,
+        defaultValue: false,
+        description: "Create subfolder with the input name",
+      })
+      .option({
+        name: "sub-folder-name-helper",
+        aliases: ["sh"],
+        description: "Default helper to apply to subfolder name when using `--create-sub-folder true`.",
+      })
+      .option({
+        name: "quiet",
+        aliases: ["q"],
+        boolean: true,
+        defaultValue: false,
+        description: "Suppress output logs (Same as --verbose 0)",
+      })
+      .option({
+        name: "verbose",
+        aliases: ["v"],
+        defaultValue: LogLevel.Info,
+        description: `Determine amount of logs to display. The values are: ${chalk.bold`0 (none) | 1 (debug) | 2 (info) | 3 (warn) | 4 (error)`}. The provided level will display messages of the same level or higher.`,
+        parse: Number,
+      })
+      .option({
+        name: "dry-run",
+        aliases: ["dr"],
+        boolean: true,
+        defaultValue: false,
+        description:
+          "Don't emit files. This is good for testing your scaffolds and making sure they " +
+          "don't fail, without having to write actual file contents or create directories.",
+      })
+      // .example({
+      //   input: `yarn cmd -t examples/test-input/Component -o examples/test-output -d '{"property":"myProp","value":"10"}'`,
+      //   description: "Usage",
+      //   output: "",
+      // })
+      .help({
+        binName: "simple-scaffold",
+        useGlobalColumns: true,
+        usageExample: "[options]",
+        header: "Create structured files based on templates.",
+        footer: [
+          `Copyright © Chen Asraf 2021`,
+          `NPM: ${chalk.underline`https://npmjs.com/package/simple-scaffold`}`,
+          `GitHub: ${chalk.underline`https://github.com/chenasraf/simple-scaffold`}`,
+        ].join("\n"),
+      })
+      .parse(args)
+  )
+}
+
+parseCliArgs()

src/index.ts

@@ -1,3 +1,4 @@
 export * from "./scaffold"
+export * from "./types"
 import Scaffold from "./scaffold"
 export default Scaffold

src/scaffold.ts

@@ -13,86 +13,123 @@ import {
   pathExists,
   pascalCase,
   isDir,
+  removeGlob,
+  makeRelativePath,
+  registerHelpers,
+  getTemplateGlobInfo,
+  ensureFileExists,
+  getFileList,
+  getBasePath,
+  copyFileTransformed,
+  getTemplateFileInfo,
+  logInitStep,
+  logInputFile,
+  GlobInfo,
+  OutputFileInfo,
 } from "./utils"
-import { ScaffoldConfig } from "./types"
+import { FileResponse, LogLevel, ScaffoldConfig } from "./types"
 
-export async function Scaffold(config: ScaffoldConfig) {
+/**
+ * Create a scaffold using given `options`.
+ *
+ * #### Create files
+ * To create a file structure to output, use any directory and file structure you would like.
+ * Inside folder names, file names or file contents, you may place `{{ var }}` where `var` is either
+ * `name` which is the scaffold name you provided or one of the keys you provided in the `data` option.
+ *
+ * The contents and names will be replaced with the transformed values so you can use your original structure as a
+ * boilerplate for other projects, components, modules, or even single files.
+ *
+ * #### Helpers
+ * Helpers are functions you can use to transform your `{{ var }}` contents into other values without having to
+ * pre-define the data and use a duplicated key. Common cases are transforming name-case format
+ * (e.g. `MyName` → `my_name`), so these have been provided as defaults:
+ *
+ * | Helper name | Example code            | Example output |
+ * | ----------- | ----------------------- | -------------- |
+ * | camelCase   | `{{ camelCase name }}`  | myName         |
+ * | snakeCase   | `{{ snakeCase name }}`  | my_name        |
+ * | startCase   | `{{ startCase name }}`  | My Name        |
+ * | kebabCase   | `{{ kebabCase name }}`  | my-name        |
+ * | hyphenCase  | `{{ hyphenCase name }}` | my-name        |
+ * | pascalCase  | `{{ pascalCase name }}` | MyName         |
+ * | upperCase   | `{{ upperCase name }}`  | MYNAME         |
+ * | lowerCase   | `{{ lowerCase name }}`  | myname         |
+ *
+ * Any functions you provide in `helpers` option will also be available to you to make custom formatting as you see fit
+ * (for example, formatting a date)
+ */
+export async function Scaffold({ ...options }: ScaffoldConfig) {
+  options.output ??= process.cwd()
+
+  registerHelpers(options)
   try {
-    const options = { ...config }
-    const data = { name: options.name, Name: pascalCase(options.name), ...options.data }
-    log(options, "Config:", {
-      name: options.name,
-      templates: options.templates,
-      output: options.output,
-      createSubfolder: options.createSubFolder,
-      data: options.data,
-      overwrite: options.overwrite,
-      quiet: options.quiet,
-    })
-    log(options, "Data:", data)
-    for (let template of config.templates) {
+    options.data = { name: options.name, Name: pascalCase(options.name), ...options.data }
+    logInitStep(options)
+    for (let _template of options.templates) {
       try {
-        const _isDir = await isDir(template)
-        const basePath = path
-          .resolve(process.cwd(), _isDir ? template : path.dirname(template.replace("*", "").replace("//", "/")))
-          .replace(process.cwd(), ".")
-        if (_isDir) {
-          template = template + "/**/*"
-        }
-        const files = await promisify(glob)(template, { dot: true, debug: false })
-        for (const templatePath of files) {
-          if (!(await isDir(templatePath))) {
-            await handleTemplateFile(templatePath, basePath, options, data)
+        const { nonGlobTemplate, origTemplate, isDirOrGlob, isGlob, template } = await getTemplateGlobInfo(
+          options,
+          _template
+        )
+        await ensureFileExists(template, isDirOrGlob)
+        const files = await getFileList(options, template)
+        for (const inputFilePath of files) {
+          if (await isDir(inputFilePath)) {
+            continue
           }
+          const relPath = makeRelativePath(path.dirname(removeGlob(inputFilePath).replace(nonGlobTemplate, "")))
+          const basePath = getBasePath(relPath)
+          logInputFile(options, {
+            origTemplate,
+            relPath,
+            template,
+            inputFilePath,
+            nonGlobTemplate,
+            basePath,
+            isDirOrGlob,
+            isGlob,
+          })
+          await handleTemplateFile(options, options.data, { templatePath: inputFilePath, basePath })
         }
       } catch (e: any) {
         handleErr(e)
       }
     }
   } catch (e: any) {
-    console.error(e)
+    log(options, LogLevel.Error, e)
     throw e
   }
 }
-
 async function handleTemplateFile(
-  templatePath: string,
-  basePath: string,
   options: ScaffoldConfig,
-  data: Record<string, string>
+  data: Record<string, string>,
+  { templatePath, basePath }: { templatePath: string; basePath: string }
 ): Promise<void> {
   return new Promise(async (resolve, reject) => {
     try {
-      log(options, `Parsing ${templatePath}`)
-      const inputPath = path.join(process.cwd(), templatePath)
-      const outputPathOpt = getOptionValueForFile(inputPath, data, options.output)
-      const outputDir = path.resolve(
-        process.cwd(),
-        ...([outputPathOpt, options.createSubFolder ? options.name : undefined].filter(Boolean) as string[])
+      const { inputPath, outputPathOpt, outputDir, outputPath, exists } = await getTemplateFileInfo(options, data, {
+        templatePath,
+        basePath,
+      })
+      const overwrite = getOptionValueForFile(options, inputPath, data, options.overwrite ?? false)
+
+      log(
+        options,
+        LogLevel.Debug,
+        `\nParsing ${templatePath}`,
+        `\nBase path: ${basePath}`,
+        `\nFull input path: ${inputPath}`,
+        `\nOutput Path Opt: ${outputPathOpt}`,
+        `\nFull output dir: ${outputDir}`,
+        `\nFull output path: ${outputPath}`,
+        `\n`
       )
-      const outputPath = path.join(outputDir, handlebarsParse(path.basename(inputPath), data))
-      const overwrite = getOptionValueForFile(inputPath, data, options.overwrite ?? false)
-      const exists = await pathExists(outputPath)
 
-      await createDirIfNotExists(outputDir, options)
+      await createDirIfNotExists(path.dirname(outputPath), options)
 
-      log(options, `Writing to ${outputPath}`)
-      if (!exists || overwrite) {
-        if (exists && overwrite) {
-          log(options, `File ${outputPath} exists, overwriting`)
-        }
-        const templateBuffer = await readFile(inputPath)
-        const outputContents = handlebarsParse(templateBuffer, data)
-
-        if (!options.dryRun) {
-          await writeFile(outputPath, outputContents)
-        } else {
-          log(options, "Content output:")
-          log(options, outputContents)
-        }
-      } else if (exists) {
-        log(options, `File ${outputPath} already exists, skipping`)
-      }
+      log(options, LogLevel.Info, `Writing to ${outputPath}`)
+      await copyFileTransformed(options, data, { exists, overwrite, outputPath, inputPath })
       resolve()
     } catch (e: any) {
       handleErr(e)

src/types.d.ts

@@ -1,24 +0,0 @@
-export type FileResponseFn<T> = (fullPath: string, basedir: string, basename: string) => T
-
-export type FileResponse<T> = T | FileResponseFn<T>
-
-export interface ScaffoldConfig {
-  name: string
-  templates: string[]
-  output: FileResponse<string>
-  createSubFolder?: boolean
-  data?: Record<string, string>
-  overwrite?: FileResponse<boolean>
-  quiet?: boolean
-  dryRun?: boolean
-}
-export interface ScaffoldCmdConfig {
-  name: string
-  templates: string[]
-  output: string
-  createSubFolder: boolean
-  data?: Record<string, string>
-  overwrite: boolean
-  quiet: boolean
-  dryRun: boolean
-}

src/types.ts

@@ -0,0 +1,127 @@
+export enum LogLevel {
+  None = 0,
+  Debug = 1,
+  Info = 2,
+  Warning = 3,
+  Error = 4,
+}
+
+export type FileResponseFn<T> = (fullPath: string, basedir: string, basename: string) => T
+
+export type FileResponse<T> = T | FileResponseFn<T>
+
+export type DefaultHelperKeys =
+  | "camelCase"
+  | "snakeCase"
+  | "startCase"
+  | "kebabCase"
+  | "hyphenCase"
+  | "pascalCase"
+  | "lowerCase"
+  | "upperCase"
+
+export type HelperKeys<T> = DefaultHelperKeys | T
+
+export type Helper = (text: string) => string
+
+export interface ScaffoldConfig {
+  /**
+   * Name to be passed to the generated files. `{{name}}` and `{{Name}}` inside contents and file names will be replaced
+   * accordingly.
+   */
+  name: string
+
+  /**
+   * Template files to use as input. You may provide multiple files, each of which can be a relative or absolute path,
+   * or a glob pattern for multiple file matching easily. (default: current working directory)
+   */
+  templates: string[]
+
+  /** Path to output to. If `createSubFolder` is `true`, the subfolder will be created inside this path. */
+  output: FileResponse<string>
+
+  /**
+   * Create subfolder with the input name (default: `false`)
+   */
+  createSubFolder?: boolean
+
+  /**
+   * Add custom data to the templates. By default, only your app name is included as `{{name}}` and `{{Name}}`.
+   */
+  data?: Record<string, string>
+
+  /**
+   * Enable to override output files, even if they already exist. (default: `false`)
+   *
+   * You may supply a function to this option, which can take the arguments `(fullPath, baseDir, baseName)` and returns
+   * a string, to return a dynamic path for each file.
+   */
+  overwrite?: FileResponse<boolean>
+
+  /** Suppress output logs (Same as `verbose: 0` or `verbose: LogLevel.None`) */
+  quiet?: boolean
+
+  /**
+   * Determine amount of logs to display.
+   *
+   * The values are: `0 (none) | 1 (debug) | 2 (info) | 3 (warn) | 4 (error)`. The provided level will display messages
+   * of the same level or higher. (default: `2 (info)`)
+   * @see LogLevel
+   */
+  verbose?: LogLevel
+
+  /**
+   * Don't emit files. This is good for testing your scaffolds and making sure they don't fail, without having to write
+   * actual file contents or create directories. (default: `false`)
+   */
+  dryRun?: boolean
+
+  /**
+   * Additional helpers to add to the template parser. Provide an object whose keys are the name of the function to add,
+   * and the value is the helper function itself. The signature of helpers is as follows:
+   * ```typescript
+   * (text: string) => string
+   * ```
+   *
+   * A full example might be:
+   *
+   * ```typescript
+   * Scaffold({
+   *   //...
+   *   helpers: {
+   *     upperCamelCase: (text) => camelCase(text).toUpperCase()
+   *   }
+   * })
+   * ```
+   *
+   * Here are the built-in helpers available for use:
+   * | Helper name | Example code            | Example output |
+   * | ----------- | ----------------------- | -------------- |
+   * | camelCase   | `{{ camelCase name }}`  | myName         |
+   * | snakeCase   | `{{ snakeCase name }}`  | my_name        |
+   * | startCase   | `{{ startCase name }}`  | My Name        |
+   * | kebabCase   | `{{ kebabCase name }}`  | my-name        |
+   * | hyphenCase  | `{{ hyphenCase name }}` | my-name        |
+   * | pascalCase  | `{{ pascalCase name }}` | MyName         |
+   * | upperCase   | `{{ upperCase name }}`  | MYNAME         |
+   * | lowerCase   | `{{ lowerCase name }}`  | myname         |
+   */
+  helpers?: Record<string, Helper>
+
+  /**
+   * Default transformer to apply to subfolder name when using `createSubFolder: true`. Can be one of the default
+   * helpers, or a custom one you provide to `helpers`. Defaults to `undefined`, which means no transformation is done.
+   */
+  subFolderNameHelper?: DefaultHelperKeys | string
+}
+export interface ScaffoldCmdConfig {
+  name: string
+  templates: string[]
+  output: string
+  createSubFolder: boolean
+  data?: Record<string, string>
+  overwrite: boolean
+  quiet: boolean
+  verbose: LogLevel
+  dryRun: boolean
+}

src/utils.ts

@@ -1,36 +1,65 @@
 import path from "path"
 import { F_OK } from "constants"
-import { FileResponse, FileResponseFn, ScaffoldConfig } from "./types"
+import { DefaultHelperKeys, FileResponse, FileResponseFn, Helper, LogLevel, ScaffoldConfig } from "./types"
 import camelCase from "lodash/camelCase"
 import snakeCase from "lodash/snakeCase"
 import kebabCase from "lodash/kebabCase"
 import startCase from "lodash/startCase"
 import Handlebars from "handlebars"
 import { promises as fsPromises } from "fs"
+import chalk from "chalk"
 const { stat, access, mkdir } = fsPromises
 
-const helpers = {
+import { glob } from "glob"
+import { promisify } from "util"
+const { readFile, writeFile } = fsPromises
+
+export const defaultHelpers: Record<DefaultHelperKeys, Helper> = {
   camelCase,
   snakeCase,
   startCase,
   kebabCase,
   hyphenCase: kebabCase,
   pascalCase,
+  lowerCase: (text) => text.toLowerCase(),
+  upperCase: (text) => text.toUpperCase(),
 }
 
-for (const helperName in helpers) {
-  Handlebars.registerHelper(helperName, helpers[helperName as keyof typeof helpers])
+export function registerHelpers(options: ScaffoldConfig) {
+  const _helpers = { ...defaultHelpers, ...options.helpers }
+  for (const helperName in _helpers) {
+    log(options, LogLevel.Debug, `Registering helper: ${helperName}`)
+    Handlebars.registerHelper(helperName, _helpers[helperName as keyof typeof _helpers])
+  }
 }
 
 export function handleErr(err: NodeJS.ErrnoException | null) {
   if (err) throw err
 }
 
-export function log(options: ScaffoldConfig, ...obj: any[]) {
-  if (options.quiet) {
+export function log(options: ScaffoldConfig, level: LogLevel, ...obj: any[]) {
+  if (options.quiet || options.verbose === LogLevel.None || level < (options.verbose ?? LogLevel.Info)) {
     return
   }
-  console["log"](...obj)
+  const levelColor: Record<LogLevel, keyof typeof chalk> = {
+    [LogLevel.None]: "reset",
+    [LogLevel.Debug]: "blue",
+    [LogLevel.Info]: "dim",
+    [LogLevel.Warning]: "yellow",
+    [LogLevel.Error]: "red",
+  }
+  const chalkFn: any = chalk[levelColor[level]]
+  const key: "log" | "warn" | "error" = level === LogLevel.Error ? "error" : level === LogLevel.Warning ? "warn" : "log"
+  const logFn: any = console[key]
+  logFn(
+    ...obj.map((i) =>
+      i instanceof Error
+        ? chalkFn(i, JSON.stringify(i, undefined, 1), i.stack)
+        : typeof i === "object"
+        ? chalkFn(JSON.stringify(i, undefined, 1))
+        : chalkFn(i)
+    )
+  )
 }
 
 export async function createDirIfNotExists(dir: string, options: ScaffoldConfig): Promise<void> {
@@ -42,6 +71,7 @@ export async function createDirIfNotExists(dir: string, options: ScaffoldConfig)
 
   if (!(await pathExists(dir))) {
     try {
+      log(options, LogLevel.Debug, `Creating dir ${dir}`)
       await mkdir(dir)
       return
     } catch (e: any) {
@@ -54,6 +84,7 @@ export async function createDirIfNotExists(dir: string, options: ScaffoldConfig)
 }
 
 export function getOptionValueForFile<T>(
+  options: ScaffoldConfig,
   filePath: string,
   data: Record<string, string>,
   fn: FileResponse<T>,
@@ -64,15 +95,24 @@ export function getOptionValueForFile<T>(
   }
   return (fn as FileResponseFn<T>)(
     filePath,
-    path.dirname(handlebarsParse(filePath, data)),
-    path.basename(handlebarsParse(filePath, data))
+    path.dirname(handlebarsParse(options, filePath, data).toString()),
+    path.basename(handlebarsParse(options, filePath, data).toString())
   )
 }
 
-export function handlebarsParse(templateBuffer: Buffer | string, data: Record<string, string>) {
-  const parser = Handlebars.compile(templateBuffer.toString(), { noEscape: true })
-  const outputContents = parser(data)
-  return outputContents
+export function handlebarsParse(
+  options: ScaffoldConfig,
+  templateBuffer: Buffer | string,
+  data: Record<string, string>
+) {
+  try {
+    const parser = Handlebars.compile(templateBuffer.toString(), { noEscape: true })
+    const outputContents = parser(data)
+    return outputContents
+  } catch {
+    log(options, LogLevel.Warning, "Couldn't parse file with handlebars, returning original content")
+    return templateBuffer
+  }
 }
 
 export async function pathExists(filePath: string): Promise<boolean> {
@@ -95,3 +135,185 @@ export async function isDir(path: string): Promise<boolean> {
   const tplStat = await stat(path)
   return tplStat.isDirectory()
 }
+
+export function removeGlob(template: string) {
+  return template.replace(/\*/g, "").replace(/\/\//g, "/")
+}
+
+export function makeRelativePath(str: string): string {
+  return str.startsWith("/") ? str.slice(1) : str
+}
+
+export function getBasePath(relPath: string) {
+  return path
+    .resolve(process.cwd(), relPath)
+    .replace(process.cwd() + "/", "")
+    .replace(process.cwd(), "")
+}
+
+export async function getFileList(options: ScaffoldConfig, template: string) {
+  return await promisify(glob)(template, {
+    dot: true,
+    debug: options.verbose === LogLevel.Debug,
+    nodir: true,
+  })
+}
+
+export interface GlobInfo {
+  nonGlobTemplate: string
+  origTemplate: string
+  isDirOrGlob: boolean
+  isGlob: boolean
+  template: string
+}
+
+export async function getTemplateGlobInfo(options: ScaffoldConfig, template: string): Promise<GlobInfo> {
+  const isGlob = glob.hasMagic(template)
+  log(options, LogLevel.Debug, "before isDir", "isGlob:", isGlob, template)
+  let _template = template
+  const nonGlobTemplate = isGlob ? removeGlob(template) : template
+  const isDirOrGlob = isGlob ? true : await isDir(template)
+  log(options, LogLevel.Debug, "after isDir", isDirOrGlob)
+  const _shouldAddGlob = !isGlob && isDirOrGlob
+  const origTemplate = template
+  if (_shouldAddGlob) {
+    _template = template + "/**/*"
+  }
+  return { nonGlobTemplate, origTemplate, isDirOrGlob, isGlob, template: _template }
+}
+
+export async function ensureFileExists(template: string, isGlob: boolean) {
+  if (!isGlob && !(await pathExists(template))) {
+    const err: NodeJS.ErrnoException = new Error(`ENOENT, no such file or directory ${template}`)
+    err.code = "ENOENT"
+    err.path = template
+    err.errno = -2
+    throw err
+  }
+}
+
+export interface OutputFileInfo {
+  inputPath: string
+  outputPathOpt: string
+  outputDir: string
+  outputPath: string
+  exists: boolean
+}
+
+export async function getTemplateFileInfo(
+  options: ScaffoldConfig,
+  data: Record<string, string>,
+  { templatePath, basePath }: { templatePath: string; basePath: string }
+): Promise<OutputFileInfo> {
+  const inputPath = path.resolve(process.cwd(), templatePath)
+  const outputPathOpt = getOptionValueForFile(options, inputPath, data, options.output)
+  const outputDir = getOutputDir(options, data, outputPathOpt, basePath)
+  const outputPath = handlebarsParse(options, path.join(outputDir, path.basename(inputPath)), data).toString()
+  const exists = await pathExists(outputPath)
+  return { inputPath, outputPathOpt, outputDir, outputPath, exists }
+}
+
+export async function copyFileTransformed(
+  options: ScaffoldConfig,
+  data: Record<string, string>,
+  {
+    exists,
+    overwrite,
+    outputPath,
+    inputPath,
+  }: { exists: boolean; overwrite: boolean; outputPath: string; inputPath: string }
+) {
+  if (!exists || overwrite) {
+    if (exists && overwrite) {
+      log(options, LogLevel.Info, `File ${outputPath} exists, overwriting`)
+    }
+    const templateBuffer = await readFile(inputPath)
+    const outputContents = handlebarsParse(options, templateBuffer, data)
+
+    if (!options.dryRun) {
+      await writeFile(outputPath, outputContents)
+      log(options, LogLevel.Info, "Done.")
+    } else {
+      log(options, LogLevel.Info, "Content output:")
+      log(options, LogLevel.Info, outputContents)
+    }
+  } else if (exists) {
+    log(options, LogLevel.Info, `File ${outputPath} already exists, skipping`)
+  }
+}
+
+export function getOutputDir(
+  options: ScaffoldConfig,
+  data: Record<string, string>,
+  outputPathOpt: string,
+  basePath: string
+) {
+  return path.resolve(
+    process.cwd(),
+    ...([
+      outputPathOpt,
+      basePath,
+      options.createSubFolder
+        ? options.subFolderNameHelper
+          ? handlebarsParse(options, `{{ ${options.subFolderNameHelper} name }}`, data)
+          : options.name
+        : undefined,
+    ].filter(Boolean) as string[])
+  )
+}
+
+export function logInputFile(
+  options: ScaffoldConfig,
+  {
+    origTemplate,
+    relPath,
+    template,
+    inputFilePath,
+    nonGlobTemplate,
+    basePath,
+    isDirOrGlob,
+    isGlob,
+  }: {
+    origTemplate: string
+    relPath: string
+    template: string
+    inputFilePath: string
+    nonGlobTemplate: string
+    basePath: string
+    isDirOrGlob: boolean
+    isGlob: boolean
+  }
+) {
+  log(
+    options,
+    LogLevel.Debug,
+    `\nprocess.cwd(): ${process.cwd()}`,
+    `\norigTemplate: ${origTemplate}`,
+    `\nrelPath: ${relPath}`,
+    `\ntemplate: ${template}`,
+    `\ninputFilePath: ${inputFilePath}`,
+    `\nnonGlobTemplate: ${nonGlobTemplate}`,
+    `\nbasePath: ${basePath}`,
+    `\nisDirOrGlob: ${isDirOrGlob}`,
+    `\nisGlob: ${isGlob}`,
+    `\n`
+  )
+}
+
+export function logInitStep(options: ScaffoldConfig) {
+  log(options, LogLevel.Debug, "Full config:", {
+    name: options.name,
+    templates: options.templates,
+    output: options.output,
+    createSubfolder: options.createSubFolder,
+    data: options.data,
+    overwrite: options.overwrite,
+    quiet: options.quiet,
+    subFolderTransformHelper: options.subFolderNameHelper,
+    helpers: Object.keys(options.helpers ?? {}),
+    verbose: `${options.verbose} (${Object.keys(LogLevel).find(
+      (k) => (LogLevel[k as any] as unknown as number) === options.verbose!
+    )})`,
+  })
+  log(options, LogLevel.Info, "Data:", options.data)
+}

tests/scaffold.test.ts

@@ -2,6 +2,8 @@ import mockFs from "mock-fs"
 import FileSystem from "mock-fs/lib/filesystem"
 import Scaffold from "../src/scaffold"
 import { readdirSync, readFileSync } from "fs"
+import { Console } from "console"
+import { defaultHelpers } from "../src/utils"
 
 const fileStructNormal = {
   input: {
@@ -19,21 +21,52 @@ const fileStructWithData = {
 
 const fileStructNested = {
   input: {
-    "{{name}}-1.text": "This should be in root",
+    "{{name}}-1.txt": "This should be in root",
     "{{Name}}": {
       "{{name}}-2.txt": "Hello, my value is {{value}}",
+      moreNesting: {
+        "{{name}}-3.txt": "Hi! My value is actually NOT {{value}}!",
+      },
     },
   },
   output: {},
 }
+const fileStructSubdirTransformer = {
+  input: {
+    "{{name}}.txt": "Hello, my app is {{name}}",
+  },
+  output: {},
+}
 
+const defaultHelperNames = Object.keys(defaultHelpers)
+const fileStructHelpers = {
+  input: {
+    defaults: defaultHelperNames.reduce<Record<string, string>>(
+      (all, cur) => ({ ...all, [cur + ".txt"]: `{{ ${cur} name }}` }),
+      {}
+    ),
+    custom: {
+      "add1.txt": "{{ add1 name }}",
+    },
+  },
+  output: {},
+}
+// let logsTemp: any = []
+// let logMock: any
 function withMock(fileStruct: FileSystem.DirectoryItems, testFn: jest.EmptyFunction): jest.EmptyFunction {
   return () => {
     beforeEach(() => {
+      // console.log("Mocking:", fileStruct)
+      console = new Console(process.stdout, process.stderr)
+
       mockFs(fileStruct)
+      // logMock = jest.spyOn(console, 'log').mockImplementation((...args) => {
+      //   logsTemp.push(args)
+      // })
     })
     testFn()
     afterEach(() => {
+      // console.log("Restoring mock")
       mockFs.restore()
     })
   }
@@ -48,9 +81,8 @@ describe("Scaffold", () => {
           name: "app_name",
           output: "output",
           templates: ["input"],
-          quiet: true,
+          verbose: 0,
         })
-
         const data = readFileSync(process.cwd() + "/output/app_name.txt")
         expect(data.toString()).toBe("Hello, my app is app_name")
       })
@@ -61,7 +93,7 @@ describe("Scaffold", () => {
           output: "output",
           templates: ["input"],
           createSubFolder: true,
-          quiet: true,
+          verbose: 0,
         })
 
         const data = readFileSync(process.cwd() + "/output/app_name/app_name.txt")
@@ -79,7 +111,7 @@ describe("Scaffold", () => {
           output: "output",
           templates: ["input"],
           data: { value: "1" },
-          quiet: true,
+          verbose: 0,
         })
 
         await Scaffold({
@@ -87,7 +119,7 @@ describe("Scaffold", () => {
           output: "output",
           templates: ["input"],
           data: { value: "2" },
-          quiet: true,
+          verbose: 0,
         })
 
         const data = readFileSync(process.cwd() + "/output/app_name.txt")
@@ -100,7 +132,7 @@ describe("Scaffold", () => {
           output: "output",
           templates: ["input"],
           data: { value: "1" },
-          quiet: true,
+          verbose: 0,
         })
 
         await Scaffold({
@@ -109,7 +141,7 @@ describe("Scaffold", () => {
           templates: ["input"],
           data: { value: "2" },
           overwrite: true,
-          quiet: true,
+          verbose: 0,
         })
 
         const data = readFileSync(process.cwd() + "/output/app_name.txt")
@@ -121,9 +153,13 @@ describe("Scaffold", () => {
   describe(
     "errors",
     withMock(fileStructNormal, () => {
-      let consoleMock: jest.SpyInstance
+      let consoleMock1: jest.SpyInstance
       beforeAll(() => {
-        consoleMock = jest.spyOn(console, "error").mockImplementation(() => void 0)
+        consoleMock1 = jest.spyOn(console, "error").mockImplementation(() => void 0)
+      })
+
+      afterAll(() => {
+        consoleMock1.mockRestore()
       })
 
       test("should throw for bad input", async () => {
@@ -133,16 +169,12 @@ describe("Scaffold", () => {
             output: "output",
             templates: ["non-existing-input"],
             data: { value: "1" },
-            quiet: true,
+            verbose: 0,
           })
         ).rejects.toThrow()
 
         expect(() => readFileSync(process.cwd() + "/output/app_name.txt")).toThrow()
       })
-
-      afterAll(() => {
-        consoleMock.mockRestore()
-      })
     })
   )
 
@@ -155,7 +187,7 @@ describe("Scaffold", () => {
           output: (fullPath, basedir, basename) => `custom-output/${basename.split(".")[0]}`,
           templates: ["input"],
           data: { value: "1" },
-          quiet: true,
+          verbose: 0,
         })
         const data = readFileSync(process.cwd() + "/custom-output/app_name/app_name.txt")
         expect(data.toString()).toBe("Hello, my app is app_name")
@@ -169,14 +201,128 @@ describe("Scaffold", () => {
       test("should maintain input structure on output", async () => {
         await Scaffold({
           name: "app_name",
-          output: "./",
+          output: "output",
           templates: ["input"],
           data: { value: "1" },
-          quiet: true,
+          verbose: 0,
         })
 
-        const dir = readdirSync(process.cwd())
+        const rootDir = readdirSync(process.cwd() + "/output")
+        const dir = readdirSync(process.cwd() + "/output/AppName")
+        const nestedDir = readdirSync(process.cwd() + "/output/AppName/moreNesting")
+        expect(rootDir).toHaveProperty("length")
         expect(dir).toHaveProperty("length")
+        expect(nestedDir).toHaveProperty("length")
+
+        const rootFile = readFileSync(process.cwd() + "/output/app_name-1.txt")
+        const oneDeepFile = readFileSync(process.cwd() + "/output/AppName/app_name-2.txt")
+        const twoDeepFile = readFileSync(process.cwd() + "/output/AppName/moreNesting/app_name-3.txt")
+        expect(rootFile.toString()).toEqual("This should be in root")
+        expect(oneDeepFile.toString()).toEqual("Hello, my value is 1")
+        expect(twoDeepFile.toString()).toEqual("Hi! My value is actually NOT 1!")
+      })
+    })
+  )
+
+  describe(
+    "helpers",
+    withMock(fileStructHelpers, () => {
+      const _helpers: Record<string, (text: string) => string> = {
+        add1: (text) => text + " 1",
+      }
+
+      describe("default helpers", () => {
+        test("should work", async () => {
+          await Scaffold({
+            name: "app_name",
+            output: "output",
+            templates: ["input"],
+            verbose: 0,
+            helpers: _helpers,
+          })
+
+          const results = {
+            camelCase: "appName",
+            snakeCase: "app_name",
+            startCase: "App Name",
+            kebabCase: "app-name",
+            hyphenCase: "app-name",
+            pascalCase: "AppName",
+            lowerCase: "app_name",
+            upperCase: "APP_NAME",
+          }
+          for (const key in results) {
+            const file = readFileSync(process.cwd() + `/output/defaults/${key}.txt`)
+            expect(file.toString()).toEqual(results[key as keyof typeof results])
+          }
+        })
+      })
+      describe("custom helpers", () => {
+        test("should work", async () => {
+          await Scaffold({
+            name: "app_name",
+            output: "output",
+            templates: ["input"],
+            verbose: 0,
+            helpers: _helpers,
+          })
+
+          const results = {
+            add1: "app_name 1",
+          }
+          for (const key in results) {
+            const file = readFileSync(process.cwd() + `/output/custom/${key}.txt`)
+            expect(file.toString()).toEqual(results[key as keyof typeof results])
+          }
+        })
+      })
+    })
+  )
+  describe(
+    "transform subfolder",
+    withMock(fileStructSubdirTransformer, () => {
+      test("should work with no helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+        })
+
+        const data = readFileSync(process.cwd() + "/output/app_name/app_name.txt")
+        expect(data.toString()).toBe("Hello, my app is app_name")
+      })
+
+      test("should work with default helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+          subFolderNameHelper: "upperCase",
+        })
+
+        const data = readFileSync(process.cwd() + "/output/APP_NAME/app_name.txt")
+        expect(data.toString()).toBe("Hello, my app is app_name")
+      })
+
+      test("should work with custom helper", async () => {
+        await Scaffold({
+          name: "app_name",
+          output: "output",
+          templates: ["input"],
+          createSubFolder: true,
+          verbose: 0,
+          subFolderNameHelper: "test",
+          helpers: {
+            test: () => "REPLACED",
+          },
+        })
+
+        const data = readFileSync(process.cwd() + "/output/REPLACED/app_name.txt")
+        expect(data.toString()).toBe("Hello, my app is app_name")
       })
     })
   )

tsconfig.json

@@ -10,11 +10,12 @@
     "declaration": true,
     "outDir": "dist",
     "strict": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "removeComments": false,
   },
   "include": [
     "src/index.ts",
-    "src/cmd.ts"
+    "src/cmd.ts",
   ],
   "exclude": [
     "tests/*"

yarn.lock

@@ -716,9 +716,9 @@ ansi-escapes@^4.2.1:
     type-fest "^0.21.3"
 
 ansi-regex@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
-  integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
 
 ansi-styles@^3.2.1:
   version "3.2.1"
@@ -932,7 +932,7 @@ chalk@2.4.2, chalk@^2.0.0:
     escape-string-regexp "^1.0.5"
     supports-color "^5.3.0"
 
-chalk@^4.0.0, chalk@^4.1.1:
+chalk@^4.0.0:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.1.tgz#c80b3fab28bf6371e6863325eee67e618b77e6ad"
   integrity sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==
@@ -940,6 +940,14 @@ chalk@^4.0.0, chalk@^4.1.1:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
+chalk@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
 char-regex@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
@@ -2153,12 +2161,12 @@ makeerror@1.0.x:
   dependencies:
     tmpl "1.0.x"
 
-massarg@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/massarg/-/massarg-0.1.2.tgz#f298741318172be14f3d2b701329fbe10eff41bb"
-  integrity sha512-gpFIjsvOoqyQnrqNDytQXPljOGlX5lvJFGYzAIqjxDqiSZwHOvz+/YfjtzrFvokfYsk0uZbE/XOH4LVRiu/1cg==
+massarg@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/massarg/-/massarg-1.0.5.tgz#3dfd49bb63bfca4b0371a2f0ffc7580a9a6cc7a0"
+  integrity sha512-gkJHZsNfeMurpVPKojCiT2lnG2cSxHPAXZSg+gCLIgCf5bGn7pKOsoeu4qVAc5mlBxV2l/hA1yojt+ZsJd8SDg==
   dependencies:
-    chalk "^4.1.1"
+    chalk "^4.1.2"
     lodash "^4.17.21"
 
 merge-stream@^2.0.0: