Simple, prompt-driven scaffolding for continuously evolving boilerplates.
ISC License
yogini is a prompt-driven scaffolding system. It makes it easy to create and maintain personal boilerplates that evolve over time.
What makes yogini different?
{useSass}main.scss
Generators created by yogini are yeoman generators, so they can be published and consumed like any other yeoman generator. You do not need to understand yeoman to use yogini.
npm install -g yo # install yeoman
npm install -g generator-yogini # install yogini
mkdir generator-mygen # create a directory for your new generator
cd generator-mygen
yo yogini # generate a blank yogini generator
npm link # alias your generator to your globally
# installed npm modules so that you can run
# it with yeoman.
mkdir mygen1 # create a directory for your new project
cd mygen1
yo mygen # generate a new project
Would you like some generator with your generator?
yogini features a 4-level architecture:
yo
wrapper that makes it easier to create, evolve, and maintain your generator.generator-mygen
. A fresh, new project!An initial yogini generator produces only a blank README, so you have to customize it to generate something useful.
TLDR;
app/templates
. All files from this directory will be copied into your project directory when you run the generator.app/yogini.json
. These will determine which files get copied (via prefixnotes) and what code gets copied (via striate).Sample yogini.json file:
{
"prompts": [
{
"type": "confirm",
"name": "js",
"message": "Does your project use Javascript?",
},
{
"type": "confirm",
"name": "css",
"message": "Does your project use css?",
}
}
}
The above yogini.json file would prompt you with two questions every time you run your generator and store the answers in js
and css
variables. These variables drive the main two aspects of scaffolding: file copying and templating.
You can use a yogini.js
file and define a parse
function which allows you to transform or add to the user-provided answers to the prompts:
module.exports = {
parse: (answers, prompts) => ({
authorName: 'Raine Revere',
authorUrl: 'https://github.com/raineorshine',
license: 'ISC',
username: 'raineorshine',
...answers,
camelize,
prettyArray,
}),
prompts: [
...
]
}
The prompts field also accepts a function which gets passed the generator instance:
{
"prompts": ({ env }) => [
{
"type": "text",
"name": "directory",
"default": env.cwd
}
}
}
You can control which files in /app/templates
get copied into your new project by prefixing filenames with expressions that include prompt variables.
.
├── index.html
├── {js}scripts
│ └── main.js
└── {css}styles
└── main.css
In the above example, the scripts folder will only be copied if js
(as declared in yogini.json) is true, and the styles
folder will only be copied if css
is true.
Empty expressions are a great way to include system and hidden files in your templates folder without them having an effect until they are copied:
{}package.json
{}.gitignore
If a folder name only consists of an expression, all files will be copied to the parent folder:
main.js
{js}
├── 1.js
├── 2.js
└── 3.js
⇨
main.js
1.js
2.js
3.js
Expressions can be any Javascript expression that evaluates to boolean
:
{js && gulp}gulpfile.js
See prefixnote for the nitty-gritty.
yogini uses striate, a superset of ejs, to control which code gets generated within the files. The answers given to the prompts in yogini.json are available as variables within the scope of your template files.
<!DOCTYPE html>
<html>
<head>
>> if(css) {
<link rel='Stylesheet' type='text/css' href='styles/main.css'>
>> }
</head>
<body>
>> if(js) {
<script src='scripts/main.js'></script>
>> }
</body>
</html>
You can see a complete yogini generator with prompts, file prefixes, and templating at generator-yogini-sample.
ISC © Raine Revere