Tool for managing code patterns
pattern-manager
provides a way to manage a folder of code patterns and their generators, which can be application-specific or shared among projects.
It searches for a folder named .patterns
in the current working directory or one of its ancestors. The .patterns
folder can contain a number of pattern folders.
A pattern folder should contain a pattern.js
, which exports a function to create the pattern, and any related template files. Each pattern is responsible to creating a copy of itself, for example: get options from the command-line or user inputs; copy files and folders; and compile templates.
To simplify the scaffolding process, the pattern generator function is provided with a set of utilities: inquirer
, handlebars
, shell
, and chalk
.
This tool is inspired by plop
.
Global
npm install pattern-manager -g
Local (for use in NPM scripts)
npm install pattern-manager -D
pat
It searches for a .patterns
folder, displays a list of patterns, and runs the selected pattern.
pat [pattern name] [...pattern options]
If a pattern name is specified, it runs that pattern.
In the .patterns
folder, there can be one or more pattern folders. These can be nested.
- Each pattern is named after its folder
- This includes the relative path, for example:
react/state
- This includes the relative path, for example:
- Each pattern folder contains
pattern.js
and any template files- Any folder that doesn't have
pattern.js
will be ignored
- Any folder that doesn't have
The job of pattern.js
is to create a copy of the pattern to its destination. It should export a function that receives a config object.
function pattern(config) {
const { src, dest } = config
// Create new pattern here
}
pattern.description = 'Desciption of pattern'
module.exports = pattern
If the function has a description
property, it will be displayed when selecting patterns.
The pattern generator function is provided with a set of properties and utility methods.
-
src
- Source path: the path of the pattern folder -
dest
- Destination path: current working folder -
argv
- Command line arguments viaminimist
-
inquirer
- Get different types of user input -
handlebars
- Compile templates -
shell
- Collection of shell commands -
chalk
- Colorful logging
Shortcuts
-
prompt
- Shortcut forinquirer.prompt
-
compile
- Shortcut forhandlebars.compile
-
compileFile
- Compile a template file and write to another file- Arguments: input file path, data object, output file path
-
error
- Display an error message and exit -
confirm
- Ask for confirmation then return true/false- Arguments: a message and optional default value (default: true)
-
command
- Shortcut forchild_process.spawnSync
with streaming output (stdio: inherit)- Arguments: command to run, array of arguments, spawnSync options
-
fileExists
- Shortcut forfs.existsSync
-
readFile
- Shortcut forfs.readFileSync
withutf8
encoding -
writeFile
- Shortcut forfs.writeFileSync
-
writeJsonFile
- Write object to human-readable JSON file- Arguments: file path, data object
If the pattern generator function returns an array of functions, they will be run as a series of promises.
The following is a basic example of pattern.js
.
- Get user input
- Compile a template and copy it to current folder
const path = require('path')
function pattern(config) {
const { src, dest, prompt, compileFile } = config
return [
() => prompt([
{
name: 'message', default: 'Hello, world',
message: 'Message to display'
}
]),
data => {
const srcFile = path.join(src, 'example.js')
const destFile = path.join(dest, 'example.js')
compileFile(srcFile, data, destFile)
console.log(`Wrote to ${destFile}`)
}
]
}
pattern.description = 'Basic pattern'
module.exports = pattern
The example.js
template:
console.log('{{message}}')
The following is an advanced example of pattern.js
.
- Take user input for the app name and description
- If the destination exists, display error and quit
- Copy all files in the pattern folder to its destination, using
rsync
- Ignore
pattern.js
itself, and everything in.gitignore
- Ignore
- Replace name and description in
package.json
- Finally, it confirms to run
git init
andnpm install
If --dry
is passed in the command line, it will do a dry run without copying anything.
const path = require('path')
function pattern(config) {
const {
src, dest, argv, prompt, error, chalk,
writeJsonFile, fileExists, quit
} = config
let name, destPath
return [
() => prompt([
{
name: 'name', default: 'app',
message: 'Name of app',
validate: function (value) {
if (value) return true
return 'App name is required'
}
},
{ name: 'description', default: '', message: 'Description' }
]),
data => {
name = data.name
destPath = path.join(dest, name)
const { description } = data
if (fileExists(destPath)) {
return error(`Destination "${name}" already exists`)
}
// ------------ Copy pattern ------------
command('rsync', [
'-vrlptz'+(argv.dry ? 'n' : ''), // -n for dry run
'--delete',
'--exclude', '.git',
'--exclude', '/pattern.js', // Exclude this file
'--filter', ':- .gitignore',
'.', // Source
destPath
], { cwd: __dirname })
if (argv.dry) quit()
// ------------ Search & replace ------------
const packagePath = path.join(destPath, 'package.json')
let packageData = require(packagePath)
packageData.name = name
packageData.description = description
writeJsonFile(packagePath, packageData)
},
// ------------ Git init ------------
() => confirm('Init .git repo?').then(confirmed => {
if (!confirmed) return
command('git', ['init'], { cwd: destPath })
}),
// ------------ npm install ------------
() => confirm('Install NPM packages?').then(confirmed => {
if (!confirmed) return
command('npm', ['install'], { cwd: destPath })
}),
() => console.log(chalk.green(`Created "${name}"`))
]
}
pattern.description = 'Advanced pattern'
module.exports = pattern