23 releases (14 breaking)

0.15.0	Jan 10, 2024
0.13.0	Feb 12, 2023
0.12.1	Jun 6, 2021
0.11.2	Dec 14, 2020
0.3.0	Jul 28, 2019

#13 in Template engine

1,828 downloads per month
Used in 14 crates

CC0 license

78KB
1.5K SLoC

handlebars_misc_helpers

A collection of helpers for handlebars (rust) to manage string, json, yaml, toml, path, file, http request.

Helpers extend the template to generate or to transform content. Few helpers are included, but if you need more helpers, ask via an issue or a PR.

To use an helper:

// arguments are space separated
{{ helper_name arguments}}

To chain helpers, use parenthesis:

{{ to_upper_case (to_singular "Hello foo-bars") }}
// -> BAR

{{ first_non_empty (unquote (json_str_query "package.edition" (read_to_str "Cargo.toml") format="toml")) (env_var "MY_VERSION") "foo" }}
// -> 2018

see Handlebars templating language

To not "import" useless dependencies, use crate's features:

[features]
default = ["string", "http_attohttpc", "json", "jsonnet"]
string = ["cruet", "enquote"]
http_attohttpc = ["attohttpc", "http_fct"]
http_reqwest = ["reqwest", "http_fct"]
http_fct = []
json = ["lazy_static", "serde", "serde_json", "serde_yaml", "toml"]
jsonnet = ["jsonnet-rs"]

String transformation
Http content
Path extraction
File
Environment variable
JSON & YAML & TOML
Assign
Replace section

String transformation

helper signature	usage sample	sample out
`replace s:String from:String to:String`	`replace "Hello old" "old" "new"`	`"Hello new"`
`to_lower_case s:String`	`to_lower_case "Hello foo-bars"`	`"hello foo-bars"`
`to_upper_case s:String`	`to_upper_case "Hello foo-bars"`	`"HELLO FOO-BARS"`
`to_camel_case s:String`	`to_camel_case "Hello foo-bars"`	`"helloFooBars"`
`to_pascal_case s:String`	`to_pascal_case "Hello foo-bars"`	`"HelloFooBars"`
`to_snake_case s:String`	`to_snake_case "Hello foo-bars"`	`"hello_foo_bars"`
`to_screaming_snake_case s:String`	`to_screaming_snake_case "Hello foo-bars"`	`"HELLO_FOO_BARS"`
`to_kebab_case s:String`	`to_kebab_case "Hello foo-bars"`	`"hello-foo-bars"`
`to_train_case s:String`	`to_train_case "Hello foo-bars"`	`"Hello-Foo-Bars"`
`to_sentence_case s:String`	`to_sentence_case "Hello foo-bars"`	`"Hello foo" bars`
`to_title_case s:String`	`to_title_case "Hello foo-bars"`	`"Hello Foo Bars"`
`to_class_case s:String`	`to_class_case "Hello foo-bars"`	`"HelloFooBar"`
`to_table_case s:String`	`to_table_case "Hello foo-bars"`	`"hello_foo_bars"`
`to_plural s:String`	`to_plural "Hello foo-bars"`	`"bars"`
`to_singular s:String`	`to_singular "Hello foo-bars"`	`"bar"`
`to_foreign_key s:String`	`to_foreign_key "Hello foo-bars"`	`"hello_foo_bars_id"`
`demodulize s:String`	`demodulize "Test::Foo::Bar"`	`"Bar"`
`ordinalize s:String+`	`ordinalize "9"`	`"9th"`
`deordinalize s:String+`	`deordinalize "9th"`	`"9"`
`trim s:String`	`trim " foo "`	`"foo"`
`trim_start s:String`	`trim_start " foo "`	`"foo "`
`trim_end s:String`	`trim_end " foo "`	`" foo"`
`unquote s:String`	`unquote "\"foo\""`	`"foo"`
`enquote symbol:String s:String`	`enquote "" "foo"`	`"\"foo\""`
`first_non_empty s:String+`	`first_non_empty "" null "foo" "bar"`	`"foo"`

Http content

Helper able to render body response from an http request.

helper signature	usage sample
`http_get url:String`	`http_get "http://hello/..."`
`gitignore_io templates:String`	`gitignore_io "rust,visualstudiocode"`

Path extraction

Helper able to extract (or transform) path (defined as string).

for the same input: "/hello/bar/foo.txt"

helper_name	sample output
file_name	`"foo.txt"`
parent	`"/hello/bar"`
extension	`"txt"`

File

Helper to read file content.

usage	output
`{{ read_to_str "/foo/bar" }}`	content of file `/foo/bar`
`{{ read_to_str "file/does/not/exist" }}`	empty string

Environment variable

Helper able to get environment variables.

helper_name	usage
env_var	`env_var "HOME"`

Specials environment variables are predefined (some of them come from std::env::consts - Rust):

variable	possible values
`"ARCH"`	x86 x86_64 arm aarch64 mips mips64 powerpc powerpc64 s390x sparc64
`"DLL_EXTENSION"`	so dylib dll
`"DLL_PREFIX"`	lib "" (an empty string)
`"DLL_SUFFIX"`	.so .dylib .dll
`"EXE_EXTENSION"`	exe "" (an empty string)
`"EXE_SUFFIX"`	.exe .nexe .pexe "" (an empty string)
`"FAMILY"`	unix windows
`"OS"`	linux macos ios freebsd dragonfly netbsd openbsd solaris android windows
`"USERNAME"`	try to find the current username, in the order: environment variable `"USERNAME"` environment variable `"username"` environment variable `"USER"` environment variable `"user"`

JSON & YAML & TOML

Helpers

json_query query:String data:Json: Helper able to extract information from json using JMESPath syntax for query.
json_str_query query:String data:String: Helper able to extract information from json using JMESPath syntax for query, data follows the requested format.
json_to_str data:Json: convert a json data into a string following the requested format.
str_to_json data:String: convert(parse) a string into a json following the requested format.

The optional requested format, is the format of the string with data:

"json" (default if omitted)
"json_pretty" json with indentation,...
"yaml"
"toml"
"toml_pretty"

usage	output
`{{ json_query "foo" {} }}`	``
`{{ json_to_str ( json_query "foo" {"foo":{"bar":{"baz":true}}} ) }}`	`{"bar":{"baz":true}}`
`{{ json_to_str ( json_query "foo" (str_to_json "{\"foo\":{\"bar\":{\"baz\":true}}}" ) ) }}`	`{"bar":{"baz":true}}`
`{{ json_str_query "foo" "{\"foo\":{\"bar\":{\"baz\":true}}}" }}`	`{"bar":{"baz":true}}`
`{{ json_str_query "foo.bar.baz" "{\"foo\":{\"bar\":{\"baz\":true}}}" }}`	`true`
`{{ json_str_query "foo" "foo:\n bar:\n baz: true\n" format="yaml"}}`	`bar:\n baz: true\n`
`{{ json_to_str ( str_to_json "{\"foo\":{\"bar\":{\"baz\":true}}}" format="json") format="yaml"}}`	`foo:\n bar:\n baz: true\n`

Blocks

`{{#from_json format="toml"}} {"foo": {"hello":"1.2.3", "bar":{"baz":true} } } {{/from_json}}`	`[foo] hello = "1.2.3"` `foo.bar baz = true`
`{{#to_json format="toml"}} [foo] bar = { baz = true } hello = "1.2.3" {{/to_json}}`	`{ "foo": { "bar": { "baz": true }, "hello": "1.2.3" } }`
`{{#from_json format="yaml"}} {"foo":{"bar":{"baz":true}}} {{/from_json}}`	`foo: bar: baz: true`
`{{#to_json format="yaml"}} foo: bar: baz: true {{/to_json}}`	`{ "foo": { "bar": { "baz": true } } }`

Note: YAML & TOML content are used as input and output format for json data. So capabilities are limited to what json support (eg. no date-time type like in TOML).

Edition via jsonnet

For more advanced edition of json, you can use jsonnet.

A data templating language for app and tool developers

See the doc of jsonnet for more samples, syntax info,...
This block can be combined with conversion helper/block for YAML & TOML to provide edition capabilities for those format
the output should a valid json, except if string_output = false is set as parameter of the block.

{{#jsonnet}}
local v = {"foo":{"bar":{"baz":false}}};
v {
  "foo" +: {
      "bar" +: {
          "baz2": true
      }
  }
}
{{/jsonnet}}

{
  "foo": {
      "bar": {
          "baz": false,
          "baz2": true
      }
  }
}

Assign

Helper able to assign (to set) a variable to use later in the template.

usage	output
`{{ assign "foo" "{}" }}`	``
`{{ assign "foo" "{}" }}{{ foo }}`	`{}`
`{{ assign "foo" "hello world" }}{{ foo }}`	`hello world`
`{{ assign "foo" {} }}{{ foo }}`	`[object]`
`{{ assign "foo" {"bar": 33} }}{{ foo }}`	`[object]`

Replace section

Helper able to replace a section delimited by a boundary.

For example with this template:

{{~#replace_section  begin="<!-- #region head-->" end="<!-- #endregion head -->" content }}
This is the new content of the block
{{~/replace_section}}

And the content having

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <!-- #region head-->
    Something by default
    <!-- #endregion head -->
  </body>
</html>

The content between  and  is replaced by the result of the inner template:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <!-- #region head-->This is the new content of the block<!-- #endregion head -->
  </body>
</html>

Note: you can remove the boundary by adding remove_boundaries=true.

Dependencies

~3–19MB
~241K SLoC