Jinja2Cpp

Jinja2с ++

Implémentation C ++ du moteur de modèle Jinja2 Python. Cette bibliothèque prend en charge les puissantes fonctionnalités de modèle Jinja2 dans le monde C ++, rapporte des pages HTML dynamiques et la génération de code source.

Introduction

Caractéristiques principales de Jinja2c ++:

• Interface publique facile à utiliser. Chargez simplement les modèles et rendez-les.
• Conformité à la spécification Jinja2
• Support complet des chaînes à caractéristiques étroites et larges à la fois pour les modèles et les paramètres.
• Réflexion intégrée pour les types C ++ communs, les bibliothèques Nlohmann et JSON rapides.
• De puissantes expressions Jinja2 complètes avec filtrage (via l'opérateur '|') et les expressions «if».
• Instructions de contrôle ( set , for , if , filter , do , with ).
• Extension des modèles, y compris et importation
• Macros
• Rich Reporting d'erreur.
• Environnement de modèle partagé avec support de cache de modèles

Par exemple, ce code simple:

# include < jinja2cpp/template.h >

std::string source = R"(
{{ ("Hello", 'world') | join }}!!!
{{ ("Hello", 'world') | join(', ') }}!!!
{{ ("Hello", 'world') | join(d = '; ') }}!!!
{{ ("Hello", 'world') | join(d = '; ') | lower }}!!!
)" ;

Template tpl;
tpl.Load(source);

std::string result = tpl.RenderAsString({}).value();

produit la chaîne de résultats:

 Helloworld!!!
Hello, world!!!
Hello; world!!!
hello; world!!!

Commencer

Pour utiliser Jinja2c ++ dans votre projet, vous devez:

• Cloner le référentiel Jinja2c ++
• Construire en fonction des instructions
• Lien vers votre projet.

L'utilisation de Jinja2c ++ dans le code est assez simple:

1. Déclarez l'objet de modèle Jinja2 :::

jinja2::Template tpl;

2. Remplissez-le avec un modèle:

tpl.Load( " {{ 'Hello World' }}!!! " );

3. Rendez le modèle:

std::cout << tpl.RenderAsString({}).value() << std::endl;

Et obtenez:

Hello World!!!

C'est tout!

Des exemples et des fonctionnalités plus détaillés peuvent être trouvés dans la documentation: https://jinja2cpp.github.io/docs/usage

Support Jinja2 actuel

Actuellement, Jinja2c ++ prend en charge le nombre limité de fonctionnalités Jinja2. Soit dit en passant, Jinja2c ++ est prévu pour être entièrement conforme aux spécifications Jinja2. Le support actuel est limité à:

• expressions. Vous pouvez utiliser presque tous les styles d'expression: simple, filtré, conditionnel, etc.
• Le grand nombre de filtres ( tri, par défaut, d'abord, dernier, longueur, max, min, inverse, unique, sum, attr, map, rejeter, rejectattr, select, selectattr, pprint, wordCount, remplacer, truncate, groupby, urlencode, capitalize, échappement, tojson, strichs, centre, xmlatr )
• Le grand nombre de testeurs ( EQ, défini, GE, GT, ITERable, LE, LT, Mapping, NE, Numéro, séquence, chaîne, indéfini, dans, même, étrange, inférieur, supérieur )
• le nombre de fonctions ( plage , boucle.cycle )
• Déclaration «si» (avec les branches «elif» et «else»)
• «Pour» (avec la branche «else» et le support «if»)
• déclaration 'inclure'
• «Importer» / 'à partir des instructions
• Instruction 'set' (Ligne et Block)
• Déclaration de «filtre»
• instructions 'étend' / 'block'
• instructions 'macro' / 'appel'
• DÉCLARATION 'AVEC'
• Énoncé d'extension 'Do'
• boucles récursives
• Contrôle de l'espace et blocs «bruts» / «Endraw»

Des informations complètes sur la table de support et de compatibilité des spécifications Jinja2 sont disponibles ici: https://jinja2cpp.github.io/docs/j2_compatibilité.html.

Compilateurs pris en charge

Compilation de Jinja2c ++ testée sur les compilateurs suivants (avec des fonctionnalités compatibles C ++ 14 et C ++ 17):

• Linux GCC 5.5 - 9.0
• Linux Clang 5.0 - 9
• CODE MACOS X 9
• CODE MACOS X 10
• MacOS X-Code 11 (C ++ 14 dans la construction par défaut, C ++ 17 avec boost fourni à l'externe)
• Microsoft Visual Studio 2015 - 2019 x86, x64
• Compilateur Mingw GCC 7.3
• Compilateur Mingw GCC 8.1

Remarque: la prise en charge de la version GCC> = 9.x ou la version Clang> = 8.0 dépend de la version de la bibliothèque boost fournie.

Statut de construction

Compilateur	Statut
MSVC 2015 (x86, x64), Mingw 7 (x64), Mingw 8 (x64)
Code X 9, 10, 11
MSVC 2017 (x86, x64), MSVC 2019 (x86, x64), C ++ 14 / C ++ 17
G ++ 5, 6, 7, 8, 9, 10, 11 Clang 5, 6, 7, 8, 9, 10, 11, 12 C ++ 14 / C ++ 17 / C ++ 20

Construire et installer

Jinja2c ++ a plusieurs dépendances externes:

• boost Library (au moins version 1.65)
• nonstd::expected-lite https://github.com/martinmoene/expected-lite
• nonstd::variant-lite https://github.com/martinmoene/variant-lite
• nonstd::optional-lite https://github.com/martinmoene/optional-lite
• nonstd::string-view-lite https://github.com/martinmoene/string-view-lite
• fmtlib::fmt https://github.com/fmtlib/fmt

Des exemples de scripts de construction et de différentes configurations de construction peuvent être trouvés ici: https://github.com/jinja2cpp/Xamples-Build

Dans un cas le plus simple pour compiler Jinja2c ++ dont vous avez besoin:

1. Installer CMake Build System (au moins la version 3.0)
2. Clone Jinja2CPP Repository:

 > git clone https://github.com/flexferrum/Jinja2Cpp.git

3. Créer un répertoire de construction:

 > cd Jinja2Cpp
> mkdir build

4. Exécutez CMake et construisez la bibliothèque:

 > cd build
> cmake .. -DCMAKE_INSTALL_PREFIX=<path to install folder>
> cmake --build . --target all

"Path to install dossier" Voici un chemin vers le dossier où vous souhaitez installer Jinja2c ++ Lib.

5. Installez la bibliothèque:

 > cmake --build . --target install

Dans ce cas, Jinja2c ++ sera construit avec des dépendances en interne et les installera respectivement. Mais Jinja2c ++ prend en charge les builds avec des DEP fournis en externe.

Utilisation avec Conan.io Manager de dépendance

Jinja2c ++ peut être utilisé comme package Conan.io. Dans ce cas, vous devez effectuer les étapes suivantes:

1. Installez conan.io selon la documentation (https://docs.conan.io/en/latest/installation.html)
2. Ajoutez une référence au package Jinja2c ++ ( jinja2cpp/1.2.1 ) à votre conanfile.txt, conanfile.py ou cmakelists.txt. Par exemple, avec l'utilisation de l'intégration conan-cmake il pourrait être écrit de cette façon:

 cmake_minimum_required ( VERSION 3.24)
project (Jinja2CppSampleConan CXX)

list ( APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR} )
list ( APPEND CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR} )

add_definitions ( "-std=c++14" )

if ( NOT EXISTS " ${CMAKE_BINARY_DIR} /conan.cmake" )
  message ( STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan" )
  file (DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/0.18.1/conan.cmake"
                " ${CMAKE_BINARY_DIR} /conan.cmake"
                TLS_VERIFY ON )
endif ()
include ( ${CMAKE_BINARY_DIR} /conan.cmake)

conan_cmake_autodetect(settings)
conan_cmake_run(REQUIRES
                    jinja2cpp/1.1.0
                    gtest/1.14.0
                BASIC_SETUP
                ${CONAN_SETTINGS}
                OPTIONS
                    jinja2cpp/*:shared= False
                    gtest/*:shared= False
                BUILD missing)

set (TARGET_NAME jinja2cpp_build_test)

add_executable ( ${TARGET_NAME} main.cpp)

target_link_libraries ( ${TARGET_NAME} ${CONAN_LIBS} )
set_target_properties ( ${TARGET_NAME} PROPERTIES
            CXX_STANDARD 14
            CXX_STANDARD_REQUIRED ON )

Flags de construction CMake supplémentaires

Vous pouvez définir l'option Cmake de ligne de commande via -d) les indicateurs de construction suivants:

• Jinja2cpp_build_tests (par défaut true) - pour construire ou non aux tests jinja2c ++.
• Jinja2cpp_strict_warnings (par défaut true) - Activer le mode strict compile-warnings (-wall -werror, etc.).
• Jinja2cpp_msvc_runtime_type (par défaut / md) - type d'exécution msvc pour lier avec (si vous utilisez le compilateur Microsoft Visual Studio).
• Jinja2cpp_deps_mode (par défaut "interne") - modes pour la gestion de la dépendance. Valeurs suivantes possibles:
  • internal dans ce mode Jinja2c ++ Build Script utilise les dépendances (inclue boost ) expédiées comme sous-projets. Rien ne doit être fourni en externe.
  • external-boost dans ce mode Jinja2c ++ Le script de construction utilise uniquement boost comme une dépendance fournis en externe. Toutes les autres dépendances sont tirées de sous-projets.
  • external dans ce mode Toutes les dépendances doivent être fournies en externe. Les chemins à boost , nonstd-* libs, etc. doivent être spécifiés via des variables Cmake standard (comme CMAKE_PREFIX_PATH ou libname_dir)
  • Mode spécial conan-build pour construire Jinja2c ++ via la recette de Conan.

Construire avec C ++ 17 Standard activé

Jinja2c ++ essaie d'utiliser des versions standard de std::variant , std::string_view et std::optional si possible.

Remerciements

Merci à @FlexFerrum pour la création de cette bibliothèque, pour être l'un des esprits les plus brillants de la communauté de l'ingénierie logicielle. Repose en paix, ami.

Merci à @ manu343726 pour l'amélioration des scripts CMake, la chasse aux insectes et la fixation et l'emballage conan.io.

Merci à @MartinMoene pour les bibliothèques XXX-Lite parfaitement implémentées.

Merci à @vitaut pour l'incroyable bibliothèque de formatage de texte.

Merci à @Martinus pour l'implémentation Fast Hash Maps.

Changelog

Version 1.3.2

Ce qui a changé

• Correction de l'analyse littérale du dict vide dans # 243
• Fixation de la protection de la rage de vie manquante pour le filtre inversé (et autres). par @ jferreyra-sc dans # 246
• Capacité à désactiver les règles d'installation de Jinjacpp par @ ilya-lavrenov dans # 250
• CMake ne trouve que RapidJson téléchargé par @ ilya-lavrenov dans # 254
• Mettre à jour les dépendances de boost de @cheaterdev dans # 253

Nouveaux contributeurs

• @ Jferreyra-SC a fait sa première contribution au # 246
• @ Ilya-Lavrenov a fait sa première contribution au # 250
• @Cheaterdev a fait sa première contribution au # 253

Version 1.3.1

Changements et améliorations

• Versions Bump Deps
• Ajouter la nouvelle liaison JSON - Boost :: JSON
• Speetup Regex Analyse en commutant pour booster :: Regex (std :: regex extrêmement lent)
  • Les modèles se chargent maintenant plus rapidement

Corriger les bugs

• petites correctifs à travers la base de code

Changements de rupture

• DEP internes maintenant utilisés via cmake fetch_content
• Le sérialiseur / désérialiseur JSON par défaut est commuté pour boost :: JSON

Version 1.2.1

Changements et améliorations

• Versions Bump Deps
• Soutenir les compilateurs modernes (jusqu'à Clang 12) et les normes (C ++ 20)
• Nettoyage du style de code minuscule

Corriger les bugs

• petites correctifs à travers la base de code

Changements de rupture

• Les DEP internes pointent pour faire une construction boost basée

Version 1.1.0

Changements et améliorations

• Filtre batch ajouté
• Filtre slice ajouté
• Filtre de format ajouté
• Filtre tojson ajouté
• striptags Filtre ajouté
• Filtre center ajouté
• Filtre xmlattr ajouté
• Tags raw / endraw ajoutés
• Répéter l'opérateur de chaîne ajouté (par exemple 'a' * 5 produira 'aaaaa' )
• Prise en charge des modèles métadonnées (étiquettes meta / endmeta ) ajoutées
• -Dlaque -fPIC ajouté à la configuration de la construction Linux

Corriger les bugs

• Corrigez le comportement des paramètres globaux LstripBlock / Trimblocks. Maintenant, il correspond complètement à l'Origina Jinja2
• Correction du bug avec le contenu block parent de rendu si l'enfant ne remplace pas ce bloc
• Correction des problèmes de compilation avec des callables définis par l'utilisateur avec le nombre d'arguments plus de 2
• Corrigez l'accès aux fonctions Jinja2 globales à partir de modèles inclus / étendus
• Correction du point d'évaluation des paramètres macro
• Réparer la boucle sur les cordes
• Avertissements de nettoyage

Changements de rupture

• À partir string_view maintenant, avec Jinja2c ++ compatible C optional 17 variant

Version 1.0.0

Changements et améliorations

• Attribut default ajouté au filtre map (# 48)
• Support de séquences d'échappement ajouté aux littéraux de cordes (# 49)
• Gammes arbitraires, séquences générées, itérateurs d'entrée, etc. peuvent désormais être utilisés avec un type de GenericList (# 66)
• non std :: string_view est maintenant l'un des types possibles de la Value
• Prise en charge de la balise filter ajoutée à l'analyseur de modèle (# 44)
• Support de filtre escape ajouté à l'analyseur de modèle (# 140)
• capitalize le support du filtre ajouté à l'analyseur de modèle (# 137)
• La version multiline de la balise set ajoutée à l'analyseur (# 45)
• Ajout d'une réflexion intégrée pour les bibliothèques de Nlohmann JSON et Rapidjson (# 78)
• loop.depth ET loop.depth0 Variables Prise en charge ajoutée
• {FMT} est maintenant utilisé comme bibliothèque de formatage au lieu d'iOStreams
• La carte de hachage Robin Hood est maintenant utilisée pour le stockage de la valeur interne
• Rendre les améliorations des performances
• Modèle de cache implémenté dans TemplateEnv
• Les callables définis par l'utilisateur peuvent désormais accepter le contexte global via *context de contexte Param spécial
• Mingw, clang> = 7.0, xcode> = 9, gcc> = 7.0 sont désormais officiellement pris en charge en tant que compilateurs cibles (# 79)

Corriger les bugs

• Précréence de | opérateur fixe (# 47)
• Correction du bug dans le convertisseur interne de char <-> wchar_t sur Windows
• Friffage fixe dans la balise endblock analyse
• Contrôle de portée fixe pour include et for les balises
• Correction d'un bug avec des macros appelle dans le contexte d'expression

Changements de rupture

• Le type d'exécution MSVC est désormais défini par JINJA2CPP_MSVC_RUNTIME_TYPE CMAKE VARIABLE

Version 0.9.2

Changements majeurs

• Les callables définis par l'utilisateur implémentés. Vous pouvez maintenant définir vos propres objets appelés, les transmettre en tant que paramètres d'entrée et les utiliser à l'intérieur de modèles comme fonctions, filtres ou testeurs réguliers (globaux). Voir les détails ici: https://jinja2cpp.github.io/docs/usage/ud_callables.html
• Vous pouvez désormais définir des paramètres globaux (modèle à l'échelle de l'environnement) accessibles à tous les modèles liés à cet environnement.
• include , import et from instructions implémentées. Maintenant, il est possible d'inclure d'autres modèles et d'utiliser des macros à partir d'autres modèles.
• with une déclaration implémentée
• do la déclaration mise en œuvre
• Exemples de projets de construction pour diverses variantes d'utilisation Jinja2C ++ créées: https://github.com/jinja2cpp/Xamples-Build
• Site de documentation créé pour Jinja2c ++: https://jinja2cpp.github.io

Changements mineurs

• Gestion des erreurs de rendu ajouté
• Mode de gestion des dépendances ajoutés au script de construction
• Correction des bogues avec des rapports d'erreur pendant la période d'analyse
• Versions améliorées des dépendances externes

Changements de rupture

• La méthode RenderAsString renvoie désormais nonstd::expected au lieu de std::string ordinaire
• Les modèles avec import , extends et include des erreurs de génération si elles sont analysées sans modèle TemplateEnv
• Les faisceaux de libération (archives) sont configurés avec le mode de gestion external des dépendances par défaut

Version 0.9.1

• Filtre applymacro ajouté qui permet d'appliquer une macro arbitraire en tant que filtre
• Dépendances pour stimuler la suppression de l'interface publique
• Les scripts CMake se sont améliorés
• Divers bogues corrigées
• Améliorer la réflexion
• Nettoyage des avertissements

Version 0.9

• Prise en charge des instructions «EXTENS» / «BLOCK»
• Prise en charge des déclarations «macro» / «appel»
• Rich Rapports d'erreur
• Prise en charge des boucles récursives
• Prise en charge du contrôle de l'espace avant et après les blocs de contrôle
• Améliorer la réflexion

Version 0.6

• De nombreux filtres ont été mis en œuvre. Ensemble complet de filtres pris en charge répertoriés ici: # 7
• De nombreux testeurs ont été mis en œuvre. Ensemble complet de testeurs pris en charge répertoriés ici: # 8
• L'opérateur 'concaténate as String' ('~') a été implémenté
• For-boucle avec la condition «Si» a été mise en œuvre
• Correction de quelques bugs dans l'analyseur