disable overwriting files + parse JSON for locals

Author: chenasraf

README.md

@@ -1,7 +1,9 @@
 # simple-scaffold
+
 Simple Scaffold allows you to create your structured files based on templates.
 
 ## Install
+
 You can either use it as a command line tool or import into your own code and run from there.
 
 ```bash
@@ -15,72 +17,81 @@ yarn [global] add simple-scaffold
 
 ### Command Line Options
 
-    Scaffold Generator
-
-      Generate scaffolds for your project based on file templates.
-      Usage: simple-scaffold scaffold-name [options]
-
-
-      -n, --name string                 Component output name
-      -t, --templates File[]            A glob pattern of template files to load.
-                                        A template file may be of any type and extension, and supports Handlebars as
-                                        a parsing engine for the file names and contents, so you may customize both
-                                        with variables from your configuration.
-      -o, --output File                 The output directory to put the new files in. They will attempt to maintain
-                                        their regular structure as they are found, if possible.
-      -l, --locals Key=Value[]          A key-value map for the template to use in parsing.
-      -S, --create-sub-folder Boolean   Whether to create a subdirectory with {{Name}} in the output directory.
-                                        default=true
-      -h, --help                        Display this help message
+```plaintext
+Scaffold Generator
+
+  Generate scaffolds for your project based on file templates.
+  Usage: simple-scaffold scaffold-name [options]
+
+Options
+
+  -n, --name string                 Component output name
+  -t, --templates File[]            A glob pattern of template files to load.
+                                    A template file may be of any type and extension, and supports Handlebars as
+                                    a parsing engine for the file names and contents, so you may customize both
+                                    with variables from your configuration.
+  -o, --output File                 The output directory to put the new files in. They will attempt to maintain
+                                    their regular structure as they are found, if possible.
+  -l, --locals Key=Value            A key-value map for the template to use in parsing.
+  -w, --overwrite Boolean           Whether to overwrite files when they are found to already exist. default=true
+  -S, --create-sub-folder Boolean   Whether to create a subdirectory with {{Name}} in the output directory.
+                                    default=true
+  -h, --help                        Display this help message
+```
 
 You can add this as a script in your `package.json`:
 
 ```json
 {
   "scripts": {
-    "scaffold": "node node_modules/simple-scaffold/dist/cmd.js --template scaffolds/component/**/* --output src/components --locals myProp=\"propname\",myVal=123"
+    "scaffold": "yarn simple-scaffold --template scaffolds/component/**/* --output src/components --locals myProp=\"propname\",myVal=123"
   }
 }
 ```
 
 ## Scaffolding
+
 Scaffolding will replace {{vars}} in both the file name and its contents and put the transformed files
 in `<output>/<{{Name}}>`, as per the Handlebars formatting rules.
 
 Your context will be pre-populated with the following:
+
 - `{{Name}}`: CapitalizedName of the component
 - `{{name}}`: camelCasedName of the component
 
 Any `locals` you add in the config will populate with their names wrapped in `{{` and `}}`.
 They are all stringified, so be sure to parse them accordingly by creating a script, if necessary.
 
 ### 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.
 The config takes similar arguments to the command line:
 
 ```javascript
-const SimpleScaffold = require('simple-scaffold').default
+const SimpleScaffold = require("simple-scaffold").default
 
 const scaffold = new SimpleScaffold({
-  name: 'component',
-  templates: [path.join(__dirname, 'scaffolds', 'component')],
-  output: path.join(__dirname, 'src', 'components'),
+  name: "component",
+  templates: [path.join(__dirname, "scaffolds", "component")],
+  output: path.join(__dirname, "src", "components"),
   createSubFolder: true,
   locals: {
-    property: 'value',
-  }
+    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 = (filename, basePath) => [basePath, filename].join(path.sep)
 ```
 
 ## Example Scaffold Input
 
 ### Input Directory structure
+
 ```
 - project
     - scaffold
@@ -91,6 +102,7 @@ config.output = (filename, basePath) => [basePath, filename].join(path.sep)
 ```
 
 #### project/scaffold/{{Name}}.js
+
 ```js
 const React = require('react')
 
@@ -102,6 +114,7 @@ module.exports = class {{Name}} extends React.Component {
 ```
 
 ### Run Example
+
 ```bash
 simple-scaffold MyComponent \
     -t project/scaffold/**/* \
@@ -110,7 +123,9 @@ simple-scaffold MyComponent \
 ```
 
 ## Example Scaffold Output
+
 #### Directory structure
+
 ```
 - project
     - src
@@ -121,6 +136,7 @@ simple-scaffold MyComponent \
 ```
 
 With `createSubfolder = false`:
+
 ```
 - project
     - src
@@ -130,12 +146,13 @@ With `createSubfolder = false`:
 ```
 
 #### project/scaffold/MyComponent/MyComponent.js
+
 ```js
-const React = require('react')
+const React = require("react")
 
 module.exports = class MyComponent extends React.Component {
   render() {
-    <div className="my-component">MyComponent Component</div>
+    ;<div className="my-component">MyComponent Component</div>
   }
 }
 ```

cmd.ts

@@ -1,83 +1,97 @@
-import SimpleScaffold from './scaffold'
-import * as fs from 'fs'
-import {IScaffold} from './index'
-import * as cliArgs from 'command-line-args'
-import * as cliUsage from 'command-line-usage'
-import * as path from 'path'
+import SimpleScaffold from "./scaffold"
+import * as fs from "fs"
+import { IScaffold } from "./index"
+import * as cliArgs from "command-line-args"
+import * as cliUsage from "command-line-usage"
+import * as path from "path"
 
-type Def = cliArgs.OptionDefinition & { description?: string, typeLabel?: string }
+type Def = cliArgs.OptionDefinition & {
+  description?: string
+  typeLabel?: string
+}
 
 function localsParser(content: string) {
-  const [key, value] = content.split('=')
-  return { [key]: value }
+  return JSON.parse(content)
 }
 
 function filePathParser(content: string) {
-  if (content.startsWith('/')) {
+  if (content.startsWith("/")) {
     return content
   }
   return [process.cwd(), content].join(path.sep)
 }
 
 function booleanParser(text: string) {
-  return text && text.trim().length ? ['true', '1', 'on'].includes(text.trim()) : true
+  return text && text.trim().length
+    ? ["true", "1", "on"].includes(text.trim())
+    : true
 }
 
 const defs: Def[] = [
   {
-    name: 'name',
-    alias: 'n',
+    name: "name",
+    alias: "n",
     type: String,
-    description: 'Component output name',
+    description: "Component output name",
     defaultOption: true,
   },
   {
-    name: 'templates',
-    alias: 't',
+    name: "templates",
+    alias: "t",
     type: filePathParser,
-    typeLabel: '{underline File}[]',
+    typeLabel: "{underline File}[]",
     description: `A glob pattern of template files to load.\nA template file may be of any type and extension, and supports Handlebars as a parsing engine for the file names and contents, so you may customize both with variables from your configuration.`,
     multiple: true,
   },
   {
-    name: 'output',
-    alias: 'o',
+    name: "output",
+    alias: "o",
     type: filePathParser,
-    typeLabel: '{underline File}',
+    typeLabel: "{underline File}",
     description: `The output directory to put the new files in. They will attempt to maintain their regular structure as they are found, if possible.`,
   },
   {
-    name: 'locals',
-    alias: 'l',
-    description: `A key-value map for the template to use in parsing.`,
-    multiple: true,
-    typeLabel: '{underline Key=Value}',
+    name: "locals",
+    alias: "l",
+    description: `A JSON string for the template to use in parsing.`,
+    typeLabel: "{underline JSON string}",
     type: localsParser,
   },
   {
-    name: 'create-sub-folder',
-    alias: 'S',
-    typeLabel: '{underline Boolean}',
-    description: 'Whether to create a subdirectory with \\{\\{Name\\}\\} in the {underline output} directory. {bold default=true}',
+    name: "overwrite",
+    alias: "w",
+    description: `Whether to overwrite files when they are found to already exist. {bold default=true}`,
+    type: booleanParser,
+    typeLabel: "{underline Boolean}",
+    defaultValue: true,
+  },
+  {
+    name: "create-sub-folder",
+    alias: "S",
+    typeLabel: "{underline Boolean}",
+    description:
+      "Whether to create a subdirectory with \\{\\{Name\\}\\} in the {underline output} directory. {bold default=true}",
     type: booleanParser,
     defaultValue: true,
   },
   {
-    name: 'help',
-    alias: 'h',
+    name: "help",
+    alias: "h",
     type: Boolean,
-    description: 'Display this help message',
+    description: "Display this help message",
   },
 ]
 
 const args = cliArgs(defs, { camelCase: true })
 
 const help = [
-  { header: 'Scaffold Generator', content: `Generate scaffolds for your project based on file templates.\nUsage: {bold simple-scaffold} {underline scaffold-name} {underline [options]}` },
-  { header: 'Options', optionList: defs }
+  {
+    header: "Scaffold Generator",
+    content: `Generate scaffolds for your project based on file templates.\nUsage: {bold simple-scaffold} {underline scaffold-name} {underline [options]}`,
+  },
+  { header: "Options", optionList: defs },
 ]
 
-args.locals = (args.locals || []).reduce((all: object, cur: object) => ({ ...all, ...cur }), {} as IScaffold.Config['locals'])
 if (args.createSubFolder === null) {
   args.createSubFolder = true
 }
@@ -87,11 +101,12 @@ if (args.help || !args.name) {
   process.exit(0)
 }
 
-console.info('Config:', args)
+console.info("Config:", args)
 new SimpleScaffold({
   name: args.name,
   templates: args.templates,
   output: args.output,
   locals: args.locals,
   createSubfolder: args.createSubFolder,
+  overwrite: args.overwrite,
 }).run()