Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/alexaegis/cpt
Copy and format with Handlebar Templates!
https://github.com/alexaegis/cpt
fs handlebar handlebars rust rust-crate rust-library template
Last synced: about 2 months ago
JSON representation
Copy and format with Handlebar Templates!
- Host: GitHub
- URL: https://github.com/alexaegis/cpt
- Owner: AlexAegis
- License: mit
- Created: 2019-11-26T19:19:17.000Z (about 5 years ago)
- Default Branch: master
- Last Pushed: 2024-01-14T11:30:58.000Z (about 1 year ago)
- Last Synced: 2024-03-15T00:21:35.670Z (10 months ago)
- Topics: fs, handlebar, handlebars, rust, rust-crate, rust-library, template
- Language: Rust
- Homepage: https://crates.io/crates/cpt
- Size: 7.92 MB
- Stars: 0
- Watchers: 4
- Forks: 0
- Open Issues: 7
-
Metadata Files:
- Readme: readme.md
- License: license
Awesome Lists containing this project
README
# cpt
[](https://github.com/AlexAegis/cpt/actions/workflows/ci.yml)
[](https://crates.io/crates/cpt)
[](https://docs.rs/cpt)
[](https://www.codacy.com/manual/AlexAegis/cpt?utm_source=github.com&utm_medium=referral&utm_content=AlexAegis/cpt&utm_campaign=Badge_Grade)
[](https://coveralls.io/github/AlexAegis/cpt?branch=master)
## Copy with Templates
Copies a folder structure and if templating data is supplied then all `.tpl` files will be converted using [Handlebars](https://github.com/wycats/handlebars.js/) and the `.tpl` file extension will then be stripped.
It does not write over existing files unless the `-f` or `--force` flag is present.
It can be run `dry` which will skip any file writes, but still logs what would it do. Use the `-d` or `--dry` flags.
Folder and file names also support Handlebars syntax. (Although you can't use `\` and many others in folder names so you are limited). After applying the template into the file/folder names, `\n` characters (since they invalid anyway) will be handled specially. At every line break the created folder structure branches off. The content of each of them will be identical.
#### For example, with this data
> The second line will be serialized as "file1.txt.tpl\nfile2.txt.tpl"
```json
{
"dir": "dir1\ndir2",
"file": ["file1.txt.tpl", "file2.txt.tpl"]
}
```
from this folder
```bash
./
./bar.txt.tpl
./{{dir}}/{{file}}
./{{dir}}/non-template.txt
```
these output files and folders will be produced
```bash
./
./bar.txt
./dir1
./dir2
./dir1/non-template.txt
./dir2/non-template.txt
./dir1/file1.txt
./dir2/file1.txt
./dir1/file2.txt
./dir2/file2.txt
```
You can try this out with this command after downloading this repository (Given that you have [Rust and Cargo](https://www.rust-lang.org/) installed):
```bash
cargo run ./templates/example_tpl_dir ./templates/example_to --json='{ \"file2\": \"bar\nbare\", \"dir\": \"dir1\ndir2\", \"file\": [\"file1.txt.tpl\", \"file2.txt.tpl\"] }'
```
## Install
### As a library
```toml
[dependencies]
cpt = "0.5.0"
```
### As a command line tool
```bash
cargo install cpt
```
## Usage
### As a library
Using shorthands
```rust
use cpt::cpt;
fn main() -> Result<(), Box> {
let from = String::from("./templates/example");
let to = String::from("./example_to");
let mut data = std::collections::HashMap::::new();
data.insert("foo".to_string(), "bar".to_string());
cpt(from, to, data) // cp(from, to) to use without templating
}
```
Using the builder
```rust
use cpt::Cpt;
fn main() -> Result<(), Box> {
let from = String::from("./templates/example");
let to = String::from("./example_to");
let mut data = std::collections::HashMap::::new();
data.insert("foo".to_string(), "bar".to_string());
Cpt::new(from, to)
.set_force(true)
.set_dry(false)
.set_data(data)
.execute()
}
```
### As a command line tool
```bash
cpt ./example ./exampletest --json='{ \"foo\": \"bar\" }'
```
Using help:
```bash
cpt --help
cpt 0.5.0
AlexAegis
Copies one folder structure to another place with files. Also formats templates!
USAGE:
cpt.exe [FLAGS] [OPTIONS]
FLAGS:
-d, --dry If set, nothing will be written to the disk
-f, --force If set, files can be overwritten in the target folder
-h, --help Prints help information
-q, --quiet Tarpaulin
-V, --version Prints version information
OPTIONS:
-j, --json JSON formatted templating data
ARGS:
The folder that will be copied [default: .]
The folder where the folder will be placed [default: ./target]
```
## Valid input
The serializer only supports strings and arrays. A valid TypeScript type of the input would look like this:
```ts
interface Input {
[key: string]: string | string[];
}
```
## Motivation
I made this for my [Advent of Code](https://www.adventofcode.com) project scaffolder which you can find in my [AoC repo](https://github.com/AlexAegis/advent-of-code).
## What's next?
For this to be a little more than just a tiny toy project the next step would be to implement context-aware templating. If we think of a template as a tree where the leaves are the contents of a file, and their parents are the names of their files, then it would be nice to pass some context to these nodes about their parents and their positions.
This would allow automatic indexing for example.
## Used libraries
- [Handlebars](https://github.com/sunng87/handlebars-rust)
> Templating engine
- [Walkdir](https://github.com/BurntSushi/walkdir)
> Recursive directory walker
- [Clap](https://github.com/clap-rs/clap)
> Command-line arguments parser
- [Serde](https://github.com/serde-rs/serde)
> Serializer, deserializer. Here used for [JSON](http://www.json.org/) parsing