ffizer
ffizer is a files and folders initializer / generator. Create any kind (or part) of project from template.
keywords: file generator, project template, project scaffolding, quickstart, project initializer, project skeleton
Motivations
Main features
- [X] project generator as a standalone executable (no shared/system dependencies (so no python + pip + ...))
- [X] a simple and generic project template (no specialisation to one ecosystem)
- [X] template as simple as possible, like a
- [X] copy or clone with file/folder renames without overwrite
- [X] few search and replace into file
- [X] template hosted as a local folder on the file system
- [X] template hosted as a git repository on any host (not only public github)
- [X] at root of the repository
- [X] in subfolder of the repository
- [X] in any revision (branch, tag, commit)
- [X] template composed of other template
- [X] composite template are regular standalone template
- [X] composite template can be apply at root folder
- [X] a fast enough project generator
Sub features
- [X] dry mode (usefull to test)
- [ ] chain commands (eg: 'git init') (like a post-hook)
- [ ] composite template include under conditions
- [X] file / folder ignored under conditions (ignores'item in ffizer.yaml are defined as handlerbar expression)
- [X] template's content can be stored under the subfolder
template
- [X] handlebars helpers
- [X] transform strings (toUpperCase, toLowerCase, Capitelize,...)
- [X] render content of GET url
- [X] render content from https://gitignore.io
- [ ] ability to update / diff / overwrite existing file
- [X] can be used as a cli or as a lib
- [ ] suggestions welcomes ;-)
Limitations
Some of the following limitations could change in the future (depends on gain/loss):
- no conditionals file or folder creation
- no framework X dedicated features
- no plugin and not extensible (without change the code)
- handlebars is the only template language supported (support for other is welcome)
Usages
Install
sh
curl https://raw.githubusercontent.com/ffizer/ffizer/master/scripts/getLatest.sh | sh
via homebrew
sh
brew tap ffizer/ffizer
brew install ffizer-bin
ffizer upgrade
via github releases
Download the binary for your platform from github releases, then unarchive it and place it your PATH.
via cargo
sh
cargo install ffizer
Run
```txt
➜ ffizer --help
ffizer 1.0.0
https://github.com/ffizer/ffizer
ffizer is a files and folders initializer / generator. Create any kind (or part) of project from template.
USAGE:
ffizer [FLAGS]
FLAGS:
-h, --help Prints help information
-V, --version Prints version information
-v, --verbose Verbose mode (-v, -vv (very verbose / level debug), -vvv) print on stderr
SUBCOMMANDS:
apply Apply a template into a target directory
help Prints this message or the help of the given subcommand(s)
upgrade Self upgrade ffizer executable
```
Self upgrade the executable
```sh
➜ ffizer upgrade --help
ffizer-upgrade 1.0.0
https://github.com/ffizer/ffizer
Self upgrade ffizer executable
USAGE:
ffizer upgrade
FLAGS:
-h, --help Prints help information
-V, --version Prints version information
```
Apply a template
```sh
➜ ffizer apply --help
ffizer-apply 1.0.0
https://github.com/ffizer/ffizer
Apply a template into a target directory
USAGE:
ffizer apply [FLAGS] [OPTIONS] --destination --source
FLAGS:
-h, --help Prints help information
--offline in offline, only local templates or cached templates are used
-V, --version Prints version information
--x-alwaysdefaultvalue should not ask for valiables values, always use defautl value or empty
(experimental)
OPTIONS:
--confirm ask confirmation 'never' or 'always' [default: never]
-d, --destination destination folder (created if doesn't exist)
--rev git revision of the template [default: master]
--source-subfolder path of the folder under the source uri to use for template
-s, --source uri / path of the template
```
use a local folder as template
sh
ffizer apply --source $HOME/my_templates/tmpl0 --destination my_project
use a remote git repository as template
sh
ffizer apply --source https://github.com/ffizer/template_sample.git --destination my_project
output
```sh
Configure variables
projectname: myproject
Plan to execute
- mkdir "my_project/"
- mkdir "myproject/dir1"
- copyraw "myproject/dir1/file11.txt"
- mkdir "myproject/dir2myproject"
- copyraw "myproject/dir2myproject/file12.txt"
- copyraw "myproject/file1.txt"
- copyrender "myproject/file2.txt"
- keep "myproject/file2.txt"
- copyrender "myproject/file3.txt"
- copyraw "myproject/file4myproject.txt"
- copyrender "myproject/file5myproject.txt"
- copyraw "myproject/file6.hbs"
```
Authoring a template
see Template Authoring - ffizer WIP
Templates
Build
sh
cargo install cargo-make --force
cargo make ci-flow
Update CHANGELOG.md
sh
cargo make update-changelog
git add CHANGELOG.md
git commit -m ':memo: (CHANGELOG) update'
Release a new version by bump patch (or minoror major)
sh
cargo make publish -- patch --dry-run
cargo make publish -- patch
Alternatives
Generic
- Cookiecutter, lot of templates, require python + pip + install dependencies on system (automatic)
- Cookiecutter — Similar projects
- sethyuan/fgen: A file generator library to be used to generate project structures, file templates and/or snippets. Templates are based on mustache. require nodejs
- project_init in rust, use mustache for templating but I have some issues with it (project template creation not obvious, github only) I could contributes but I have incompatible requirements.
- skeleton, good idea but no template file, more like a script.
- porteurbars, very similar but I discovered it too late.
Specialized
specialized to a platform, build tool,...