Jinja2Cpp

Jinja2с ++

Implementação de C ++ do mecanismo de modelo Python Jinja2. Esta biblioteca traz suporte de recursos poderosos de modelo Jinja2 no mundo C ++, relata páginas dinâmicas de HTML e geração de código -fonte.

Introdução

Principais características do Jinja2c ++:

• Interface pública fácil de usar. Basta carregar modelos e renderizá -los.
• Especificação de conformidade com Jinja2
• Suporte total de seqüências de caracteres estreitos e amplas, tanto para modelos quanto para parâmetros.
• Reflexão integrada para os tipos de C ++ comuns, Nlohmann e Rapid JSON Libraries.
• Expressões jinja2 poderosas com filtragem (via '|' | ') e' se 'expressões.
• Declarações de controle ( set , for , if , filter , do , with ).
• Extensão de modelos, incluindo e importar
• Macros
• Relatórios de erro rico.
• Ambiente de modelo compartilhado com modelos Suporte de cache

Por exemplo, este código simples:

# 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();

produz a string de resultado:

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

Começando

Para usar o jinja2c ++ em seu projeto, você precisa:

• Clone o repositório Jinja2c ++
• Construa -o de acordo com as instruções
• Link para o seu projeto.

O uso de Jinja2c ++ no código é bem simples:

1. Declare o objeto Jinja2 :: modelo:

jinja2::Template tpl;

2. Preencha -o com modelo:

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

3. Renderizar o modelo:

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

e obter:

Hello World!!!

Isso é tudo!

Exemplos e recursos mais detalhados podem ser encontrados na documentação: https://jinja2cpp.github.io/docs/usage

Suporte atual de Jinja2

Atualmente, o Jinja2C ++ suporta o número limitado de recursos de Jinja2. A propósito, o jinja2c ++ está planejado para ser um conformante de especificação totalmente Jinja2. O suporte atual é limitado a:

• expressões. Você pode usar quase todo estilo de expressão: simples, filtrado, condicional e assim por diante.
• the big number of filters ( sort, default, first, last, length, max, min, reverse, unique, sum, attr, map, reject, rejectattr, select, selectattr, pprint, dictsort, abs, float, int, list, round, random, trim, title, upper, wordcount, replace, truncate, groupby, urlencode, capitalize, escape, tojson, striptags, center, xmlattr )
• O grande número de testadores ( eq, definido, ge, gt, iterable, le, lt, mapeamento, ne, número, sequência, string, indefinido, in, uniforme, ímpar, inferior, superior )
• O número de funções ( faixa , loop.cycle )
• Declaração 'se' (com ramificações 'Elif e' else ')
• Declaração 'para' (com o ramo 'else' e 'se' suporte de peça)
• Declaração 'inclua'
• 'importar'/'de' declarações
• Declaração 'Set' (linha e bloco)
• declaração 'filtro'
• Declarações 'estende'/'bloco'
• Declarações 'macro'/'chamada'
• Declaração 'com'
• Declaração de extensão 'faça'
• Loops recursivos
• Controle espacial e blocos 'Raw'/'Endraw'

Informações completas sobre o suporte de especificação e compatibilidade do Jinja2 podem ser encontradas aqui: https://jinja2cpp.github.io/docs/j2_compatibility.html.

Compiladores suportados

Compilação de Jinja2c ++ testado nos seguintes compiladores (com C ++ 14 e C ++ 17 Recursos ativados):

• Linux GCC 5.5 - 9.0
• Linux Clang 5.0 - 9
• MacOS X-Code 9
• MacOS X-Code 10
• MacOS X-Code 11 (C ++ 14 na construção padrão, C ++ 17 com impulso fornecido externamente)
• Microsoft Visual Studio 2015 - 2019 x86, x64
• Mingw GCC Compiler 7.3
• Mingw GCC Compiler 8.1

Nota: Suporte da versão GCC> = 9.x ou CLANG Version> = 8.0 depende da versão da biblioteca Boost fornecida.

Construir status

Compilador	Status
MSVC 2015 (x86, x64), Mingw 7 (x64), Mingw 8 (x64)
Código 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

Construir e instalar

Jinja2c ++ tem várias dependências externas:

• Biblioteca boost (pelo menos versão 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

Exemplos de scripts de construção e diferentes configurações de construção podem ser encontradas aqui: https://github.com/jinja2cpp/examples-build

No caso mais simples de compilar Jinja2c ++, você precisa:

1. Instale o sistema de construção do CMake (pelo menos a versão 3.0)
2. CLONE JINJA2CPP Repositório:

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

3. Criar diretório de construção:

 > cd Jinja2Cpp
> mkdir build

4. Execute cmake e construa a biblioteca:

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

"Caminho para instalar a pasta" Aqui está um caminho para a pasta onde você deseja instalar o jinja2c ++ lib.

5. Biblioteca de instalação:

 > cmake --build . --target install

Nesse caso, o Jinja2C ++ será construído com dependências enviadas internamente e as instalará, respectivamente. Mas o Jinja2C ++ suporta compilações com deícidos fornecidos externamente.

Uso com Conan.io Gerenciador de dependência

Jinja2c ++ pode ser usado como pacote Conan.io. Nesse caso, você deve fazer as seguintes etapas:

1. Instale Conan.io de acordo com a documentação (https://docs.conan.io/en/latest/installation.html)
2. Adicione uma referência ao pacote jinja2c ++ ( jinja2cpp/1.2.1 ) ao seu conanfile.txt, conanfile.py ou cmakelists.txt. Por exemplo, com o uso da integração conan-cmake ele poderia ser escrito desta maneira:

 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 )

Bandeiras de construção de cmake adicionais

Você pode definir (via -d opção cmake de linha de comando) os seguintes sinalizadores de construção:

• Jinja2cpp_build_tests (padrão true) - para criar ou não testes jinja2c ++.
• Jinja2cpp_strict_warnings (padrão true) -Ativar modo rigoroso de compilação (-wall -werror, etc).
• Jinja2cpp_msvc_runtime_type (default /md) - MSVC Runtime Type para se vincular (se você usar o Microsoft Visual Studio Compiler).
• Jinja2cpp_deps_mode (padrão "interno") - modos para manipulação de dependência. Valores seguintes possíveis:
  • O script de compilação JinJA2C ++ internal Modo Jinja2c ++ usa dependências (incluem boost ) enviado como subprojetos. Nada precisa ser fornecido externamente.
  • external-boost nesse modo Jinja2C ++ Script usa apenas boost como uma dependência fornecida externamente. Todas as outras dependências são retiradas de subprojetos.
  • external neste modo Todas as dependências devem ser fornecidas externamente. Caminhos para boost , nonstd-* libs, etc. devem ser especificados por meio de variáveis ​​cmake padrão (como CMAKE_PREFIX_PATH ou libname_dir)
  • Modo especial conan-build para construir Jinja2c ++ via Receita Conan.

Construir com c ++ 17 padrão ativado

Jinja2c ++ tenta usar versões padrão de std::variant , std::string_view e std::optional se possível.

Agradecimentos

Agradecemos à @FlexFerrum por criar esta biblioteca, por ser uma das mentes mais brilhantes da comunidade de engenharia de software. Descanse em paz, amigo.

Agradecemos a @Manu343726 pela melhoria dos scripts do CMAKE, caça de insetos e fixação e embalagem Conan.io.

Agradecemos ao @MartinMoene pelas bibliotecas XXX-Lite perfeitamente implementadas.

Obrigado a @Vitaut pela incrível biblioteca de formatação de texto.

Obrigado a @martinus pela implementação rápida dos mapas de hash.

Changelog

Versão 1.3.2

O que mudou

• Corrija o dicto vazio Análise literal em #243
• Corrigindo a falta de proteção contra raiva da vida para o filtro reverso (e outros). por @jferreyra-sc em #246
• Capacidade de desativar as regras de instalação do Jinjacpp por @Ilya-Lavrenov em #250
• Cmake encontra apenas o Rapidjson por @Ilya-Lavrenov em #254
• Atualizar dependências Boost por @CheaterDev em #253

Novos colaboradores

• @jferreyra-sc fez sua primeira contribuição em #246
• @Ilya-Lavrenov fez sua primeira contribuição em #250
• @CheaterDev fez sua primeira contribuição em #253

Versão 1.3.1

Mudanças e melhorias

• versões Bump deps
• Adicionar nova ligação JSON - Boost :: JSON
• Speedup Regex analisando, mudando para o boost :: regex (std :: regex extremamente lento)
  • Os modelos agora estão carregando mais rápido

Corrigidos erros

• pequenas correções na base de código

Quebrando mudanças

• Deps internos agora usados ​​através do cmake fetch_content
• O Serializer/Deserializer padrão JSON é trocado para Boost :: JSON

Versão 1.2.1

Mudanças e melhorias

• versões Bump deps
• Apoie os compiladores modernos (até Clang 12) e padrões (C ++ 20)
• Limpeza de estilo de código minúsculo

Corrigidos erros

• pequenas correções na base de código

Quebrando mudanças

• Deps interno apontar para fazer compilação de impulso baseado

Versão 1.1.0

Mudanças e melhorias

• filtro batch adicionado
• Filtro slice adicionado
• filtro format adicionado
• tojson Filter adicionado
• filtro striptags adicionado
• Filtro center adicionado
• Filtro xmlattr adicionado
• Tags raw / endraw adicionadas
• Repita o operador de string adicionado (por exemplo 'a' * 5 produzirá 'aaaaa' )
• Suporte para metadados de modelos (tags meta / endmeta ) adicionados
• -fPIC sinalizador adicionado à configuração de construção do Linux

Corrigidos erros

• Corrija o comportamento das configurações globais LStripBlock/Trimblocks. Agora corresponde totalmente à Origina Jinja2
• Corrija o bug na renderização do conteúdo block pai se a criança não substituir este bloco
• Corrija problemas de compilação com callabes definidos pelo usuário com número de argumentos mais de 2
• Corrija o acesso às funções globais de Jinja2 de modelos incluídos/estendidos
• Ponto de correção de avaliação de macro params
• Corrija o looping sobre as cordas
• Avisos de limpeza

Quebrando mudanças

• A partir de agora com C ++ 17 Standard habilitado Jinja2C ++ usa versões padrão de tipos variant , string_view e optional

Versão 1.0.0

Mudanças e melhorias

• Atributo default adicionado ao filtro map (#48)
• SUPORTE DE ESCAPE SUPORTE ADICIONADOS AS LITEALS STRING (#49)
• intervalos arbitrários, sequências geradas, iteradores de entrada, etc. Agora podem ser usados ​​com o tipo GenericList (#66)
• NoNSTD :: string_view agora é um dos tipos possíveis para o Value
• Suporte de tag filter adicionado ao analisador de modelo (#44)
• Suporte ao filtro de escape adicionado ao analisador de modelo (#140)
• capitalize o suporte ao filtro adicionado ao analisador de modelo (#137)
• A versão multilina da tag set adicionada ao analisador (#45)
• Adicionado reflexão embutida para as bibliotecas Nlohmann JSON e Rapidjson (#78)
• loop.depth e loop.depth0 Variáveis ​​Suporte adicionado
• {fmt} agora é usado como uma biblioteca de formatação em vez de iostreams
• Robin Hood Hash Mapa agora é usado para armazenamento de valor interno
• renderizar melhorias de desempenho
• Cache de modelo implementado no TemplateEnv
• Callables definidos pelo usuário agora podem aceitar o contexto global via *context especial param
• Mingw, clang> = 7.0, xcode> = 9, gcc> = 7.0 agora são oficialmente suportados como compiladores de destino (#79)

Corrigidos erros

• Precedência do operador de tubo fixo ( | ) (#47)
• Corrigido o bug no char interno <-> wchar_t conversor no Windows
• Falha fixa na tag de parsagem endblock
• Controle de escopo fixo para include e for tags
• Corrigido o bug com as macros chamadas no contexto da expressão

Quebrando mudanças

• O tipo de tempo de execução do MSVC agora é definido por JINJA2CPP_MSVC_RUNTIME_TYPE cmake variável

Versão 0.9.2

Grandes mudanças

• Callables definidos pelo usuário implementados. Agora você pode definir seus próprios objetos chamáveis, passar como parâmetros de entrada e usá -los dentro de modelos como funções, filtros ou testadores regulares (globais). Veja os detalhes aqui: https://jinja2cpp.github.io/docs/usage/ud_callables.html
• Agora você pode definir parâmetros globais (em todo o ambiente) que são acessíveis para todos os modelos vinculados a esse ambiente.
• include , import e from implementadas. Agora é possível incluir outros modelos e usar macros de outros modelos.
• with a declaração implementada
• do implementada
• Projetos de construção de amostra para várias variantes de uso Jinja2c ++ criadas: https://github.com/jinja2cpp/examples-build ](https://github.com/jinja2cpp/example-build)
• Site de documentação criado para jinja2c ++: https://jinja2cpp.github.io

Pequenas mudanças

• Manipulação de erros de renderização no tempo adicionado
• Modo de gerenciamento de dependência adicionado ao script de construção
• Corrija bugs com relatórios de erro durante o tempo de análise
• Versões atualizadas de dependências externas

Quebrando mudanças

• O método RenderAsString agora retorna nonstd::expected em vez de std::string regular
• Modelos com import , extends e include erros de geração se analisar sem TemplateEnv
• Os pacotes de liberação (arquivos) são configurados com o modo de gerenciamento de dependência external por padrão

Versão 0.9.1

• applymacro o filtro Macro adicionado, o que permite aplicar macro arbitrário como um filtro
• Dependências para aumentar a interface pública da interface pública
• Os scripts cmake melhoraram
• Vários bugs corrigidos
• Melhorar a reflexão
• AVISOS LIMPEZAÇÃO

Versão 0.9

• Apoio a declarações de 'extensões'/'bloco'
• Suporte de declarações de 'Macro'/'Call'
• Relatórios de erro rico
• Suporte para loops recursivos
• Suporte ao controle de espaço antes e depois dos blocos de controle
• Melhorar a reflexão

Versão 0.6

• Muitos filtros foram implementados. Conjunto completo de filtros suportados listados aqui: #7
• Muitos testadores foram implementados. Conjunto completo de testadores suportados listados aqui: #8
• 'Concatenado como String' Operator ('~') foi implementado
• Para o loop com a condição 'se' foi implementado
• Corrigido alguns bugs no analisador