jintemplify is a versatile tool that enables users to combine Jinja2 templates with YAML variables, producing files in any desired format. The application also supports a plugin system based on shell scripts, allowing users to extend its functionality with familiar scripting techniques.
Within Jinja2 templates, you can use the vars object to access environment variables or any values passed using the --env command line option. This provides a seamless way to incorporate dynamic values into your templates based on the environment or runtime conditions.
jinja2
{{ vars.my_environment_variable }}
{{ vars.my_cli_argument }}
In the above example, my_environment_variable could be an environment variable, and my_cli_argument could be a value passed via --env.
For those looking to extend the application's functionality with plugins, here's the basic structure for the plugin configuration:
yaml
function_name:
params:
- name: parameter_name
script: your_shell_script_command_here
In this structure:
function_name is the name of the function you're adding, which can be directly called within your Jinja2 templates.params lists the parameters your function requires.script contains the shell command that the function will execute when called.esWith jintemplify, you're not limited to just basic Jinja2 templating. We've introduced specialized filters and functions to provide more flexibility:
Reading Files Directly: With the read_file function, you can directly read the contents of a file into your Jinja2 template. This is especially useful for including large chunks of data or content without manually copying them into the template.
Reading From Strings: If you have data embedded within your templates as strings, you can convert them into usable Jinja2 objects with the following filters:
from_read_json: Parse a JSON string and convert it to a Jinja2 object.from_read_yaml: Parse a YAML string and convert it to a Jinja2 object.from_read_toml: Parse a TOML string and convert it to a Jinja2 object.By using these filters, you can seamlessly integrate inline data within your templates and then manipulate them using Jinja2's powerful templating capabilities.
One of the powerful combinations you can use in jintemplify is to read a file directly and then parse its content. Here's a quick example:
```yaml {# plugin.yaml.j2 #} myreadfile: params: - name: filepath description: file path script: cat $(filepath)
```
jinja
{# main.yaml.j2 #}
{% set conf = my_read_file(file_path='./examples/test.json') | from_json %}
{{conf.hello}}
...
In this example, we're using the read_file function to read the contents of test.json. We then utilize the from_json filter to parse the read JSON string, converting it into a usable Jinja2 object. This allows you to directly access properties of the JSON, like conf.hello in the example above.
If you have Rust and Cargo installed, you can easily install jintemplify using:
bash
cargo instll jintemplify
git clone https://github.com/your_username/jintemplify.git
cd jintemplify
cargo build --release
bash
jintemplify -t <template_path> -v <variables_path> --plugin <plugin_path>
-t, --template: Specify the main Jinja2 template file.-v, --variables: Specify the YAML variables template (optional).--plugin: Specify the plugin YAML file to extend functionality.For more detailed information on each parameter, run:
bash
jintemplify --help
To add new filters, modify filter.rs. For adding or modifying plugins, see plugin.rs.
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.