Rust Web Template Engine - Neutral TS

Neutral is a web application template system, designed to work with any programming language (language-agnostic) via IPC and natively as library/crate in Rust.

In this simple PWA example, all three use exactly the same templates.

• Rust PWA example
• Python PWA example
• PHP PWA example
• Template

(*) For non-Rust requires an IPC server that you can download from the IPC repository

The documentation of the templates is here: template doc and Rust documentation here: rust doc.

Safe

Neutral is developed in Rust, one of the most secure programming languages. It does not have access to the application's data; it cannot do so because it is designed this way. It implements security mechanisms like "allow," which prevent arbitrary files from being loaded into templates. See: safety.

Features

It allows you to create templates compatible with any system and any programming language.

• Safe
• Language-agnostic
• Modular
• Parameterizable
• Efficient
• Template inheritance
• Parse files
• Embed files
• Localization
• Loops: for and each
• Snippets
• Nesting, grouping and wrapping
• Redirections: HTTP y JavaScript
• Exit with error: 403, 404, 503, ...
• Comments

How it works

Neutral TS offers two main ways to integrate with other programming languages:

• In Rust: You can use Neutral TS as a library by downloading the crate.

• In other programming languages: Inter-Process Communication (IPC) is necessary, similar to how databases like MariaDB work.

Imagine a database. It has a server, and different programming languages access the data through a client. This means that if you run a "SELECT ..." query from any programming language, the result will always be the same.

Similarly, Neutral TS has an IPC server, and each programming language has a client. No matter where you run the template, the result will always be the same.

Thanks to this, and to its modular and parameterizable design, it is possible to create utilities or plugins that will work everywhere. For example, you can develop tools to create forms or form fields and create your own libraries of "snippets" for repetitive tasks.

A small example of a plugin: countries form field and another one more practical: plugin build-form

Localization

Neutral provides powerful and easy-to-use translation utilities... define the translation in a JSON:

"locale": {
    "current": "en",
    "trans": {
        "en": {
            "Hello": "Hello",
            "ref:greeting-nts": "Hello"
        },
        "es": {
            "Hello": "Hola",
            "ref:greeting-nts": "Hola"
        },
        "de": {
            "Hello": "Hallo",
            "ref:greeting-nts": "Hallo"
        },
        "fr": {
            "Hello": "Bonjour",
            "ref:greeting-nts": "Bonjour"
        },
        "el": {
            "Hello": "Γεια σας",
            "ref:greeting-nts": "Γεια σας"
        }
    }
}

Now you can use:

{:trans; Hello :}

Actually you can always use "trans" because if there is no translation it returns the text. See: locale and trans.

Bif layout (Build-in function)

    .-- open bif
    |    .-- bif name
    |    |   .-- name separator
    |    |   |     .-- params
    |    |   |     |    .-- params/code separatos
    |    |   |     |    |    .-- code
    |    |   |     |    |    |   .-- close bif
    |    |   |     |    |    |   |
    v    v   v     v    v    v   v
    -- ----- - -------- -- ----- --
    {:snippet; snipname >>  ...  :}
    ------------------------------
            ^ -------------------
            |         ^
            |         |
            |         `-- source
            `-- Build-in function

Bif example: (See: syntax)

{:filled; varname >>
    Hello!
:}

Neutral is based on Bifs with block structure, we call the set of nested Bifs of the same level a block:

              .-- {:coalesce;
              |       {:code;
              |           {:code; ... :}
              |           {:code; ... :}
    Block --> |           {:code; ... :}
              |       :}
              |       {:code;
              |           {:code; ... :}
              |       :}
              `-- :}

                  {:coalesce;
              .------ {:code;
              |           {:code; ... :}
    Block --> |           {:code; ... :}
              |           {:code; ... :}
              `------ :}
              .------ {:code;
    Block --> |           {:code; ... :}
              `------ :}
                  :}

Short circuit at block level, if varname is not defined, the following ">>" is not evaluated:

{:defined; varname >>
    {:code;
        {:code;
            ...
        :}
    :}
:}

By design all Bifs can be nested and there can be a Bif anywhere in another Bif except in the name.

Data

The data is defined in a JSON:

"data": {
    "true": true,
    "false": false,
    "hello": "hello",
    "zero": "0",
    "one": "1",
    "spaces": "  ",
    "empty": "",
    "null": null,
    "emptyarr": [],
    "array": {
        "true": true,
        "false": false,
        "hello": "hello",
        "zero": "0",
        "one": "1",
        "spaces": "  ",
        "empty": "",
        "null": null
    }
}

And they are displayed with the bif {:; ... :} (var)

Simple variable:

{:;hello:}

Arrays with the "->" operator

{:;array->hello:}

Snippets

Snippet is a tool that can be used in a similar way to a function, it defines a snippet:

{:snippet; name >>
    Any content here, including other snippet.
:}

From then on you can invoke it like this:

{:snippet; name :}

See: snippet.

Template example

{:*
    comment
*:}
{:locale; locale.json :}
{:include; theme-snippets.ntpl :}
<!DOCTYPE html>
<html lang="{:lang;:}">
    <head>
        <title>{:trans; Site title :}</title>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        {:snippet; current-theme:head :}
        <link rel="stylesheet" href="bootstrap.min.css">
    </head>
    <body class="{:;body-class:}">
        {:snippet; current-theme:body_begin  :}
        {:snippet; current-theme:body-content :}
        {:snippet; current-theme:body-footer  :}
        <script src="jquery.min.js"></script>
    </body>
</html>

Usage

You need two things, a template file and a json schema:

{
    "config": {},
    "inherit": {
        "locale": {
            "current": "en",
            "trans": {}
        }
    },
    "data": {
        "web_site_name": "MySite"
    }
}

Template file.ntpl:

{:;web_site_name:}

Native use (Rust)

let template = Template::from_file_value("file.ntpl", schema).unwrap();
let content = template.render();

// e.g.: 200
let status_code = template.get_status_code();

// e.g.: OK
let status_text = template.get_status_text();

// empty if no error
let status_param = template.get_status_param();

// act accordingly at this point according to your framework

Rust examples

• PWA example
• actix-web
• warp
• axum
• rocket
• examples

Python

Requires an IPC server that you can download from the repository, and an IPC client that you can download here: IPC client

from NeutralIpcTemplate import NeutralIpcTemplate

template = NeutralIpcTemplate("file.ntpl", schema)
contents = template.render()

# e.g.: 200
status_code = template.get_status_code()

# e.g.: OK
status_text = template.get_status_text()

# empty if no error
status_param = template.get_status_param()

# act accordingly at this point according to your framework

Python examples

• PWA example
• example
• IPC client
• IPC server

PHP

Requires an IPC server that you can download from the repository, and an IPC client that you can download here: IPC client

include 'NeutralIpcTemplate.php';

$template = new NeutralIpcTemplate("file.ntpl", $schema);
$contents = $template->render();

// e.g.: 200
$status_code = $template->get_status_code();

// e.g.: OK
$status_text = $template->get_status_text();

// empty if no error
$status_param = $template->get_status_param();

// act accordingly at this point according to your framework

PHP examples

• PWA example
• example
• IPC client
• IPC server