[llvm] Reland Support for mustache templating language (PR #132467)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Mar 21 13:27:30 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-support
Author: Paul Kirth (ilovepi)
<details>
<summary>Changes</summary>
The last version of this patch had memory leaks due to using the
BumpPtrAllocator for data types that required destructors to run to
release heap memory (e.g. via std::vector and std::string). This version
avoids that by using smart pointers, and dropping support for
BumpPtrAllocator.
We should refactor this code to use the BumpPtrAllocator again, but that
can be addressed in future patches, since those are more invasive
changes that need to refactor many of the core data types to avoid
owning allocations.
Adds Support for the Mustache Templating Language. See specs here:
https://mustache.github.io/mustache.5.html This patch implements
support+tests for majority of the features of the language including:
- Variables
- Comments
- Lambdas
- Sections
This meant as a library to support places where we have to generate
HTML, such as in clang-doc.
Co-authored-by: Peter Chou <peter.chou@<!-- -->mail.utoronto.ca>
---
Patch is 68.00 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/132467.diff
5 Files Affected:
- (added) llvm/include/llvm/Support/Mustache.h (+127)
- (modified) llvm/lib/Support/CMakeLists.txt (+1)
- (added) llvm/lib/Support/Mustache.cpp (+763)
- (modified) llvm/unittests/Support/CMakeLists.txt (+1)
- (added) llvm/unittests/Support/MustacheTest.cpp (+1226)
``````````diff
diff --git a/llvm/include/llvm/Support/Mustache.h b/llvm/include/llvm/Support/Mustache.h
new file mode 100644
index 0000000000000..0ee9a344c0d68
--- /dev/null
+++ b/llvm/include/llvm/Support/Mustache.h
@@ -0,0 +1,127 @@
+//===--- Mustache.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of the Mustache templating language supports version 1.4.2
+// currently relies on llvm::json::Value for data input.
+// See the Mustache spec for more information
+// (https://mustache.github.io/mustache.5.html).
+//
+// Current Features Supported:
+// - Variables
+// - Sections
+// - Inverted Sections
+// - Partials
+// - Comments
+// - Lambdas
+// - Unescaped Variables
+//
+// Features Not Supported:
+// - Set Delimiter
+// - Blocks
+// - Parents
+// - Dynamic Names
+//
+// The Template class is a container class that outputs the Mustache template
+// string and is the main class for users. It stores all the lambdas and the
+// ASTNode Tree. When the Template is instantiated it tokenizes the Template
+// String and creates a vector of Tokens. Then it calls a basic recursive
+// descent parser to construct the ASTNode Tree. The ASTNodes are all stored
+// in an arena allocator which is freed once the template class goes out of
+// scope.
+//
+// Usage:
+// \code
+// // Creating a simple template and rendering it
+// auto Template = Template("Hello, {{name}}!");
+// Value Data = {{"name", "World"}};
+// std::string Out;
+// raw_string_ostream OS(Out);
+// T.render(Data, OS);
+// // Out == "Hello, World!"
+//
+// // Creating a template with a partial and rendering it
+// auto Template = Template("{{>partial}}");
+// Template.registerPartial("partial", "Hello, {{name}}!");
+// Value Data = {{"name", "World"}};
+// std::string Out;
+// raw_string_ostream OS(Out);
+// T.render(Data, OS);
+// // Out == "Hello, World!"
+//
+// // Creating a template with a lambda and rendering it
+// Value D = Object{};
+// auto T = Template("Hello, {{lambda}}!");
+// Lambda L = []() -> llvm::json::Value { return "World"; };
+// T.registerLambda("lambda", L);
+// std::string Out;
+// raw_string_ostream OS(Out);
+// T.render(D, OS);
+// // Out == "Hello, World!"
+// \endcode
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_MUSTACHE
+#define LLVM_SUPPORT_MUSTACHE
+
+#include "Error.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/StringSaver.h"
+#include <functional>
+#include <vector>
+
+namespace llvm::mustache {
+
+using Lambda = std::function<llvm::json::Value()>;
+using SectionLambda = std::function<llvm::json::Value(std::string)>;
+
+class ASTNode;
+using AstPtr = std::unique_ptr<ASTNode>;
+
+// A Template represents the container for the AST and the partials
+// and Lambdas that are registered with it.
+class Template {
+public:
+ Template(StringRef TemplateStr);
+
+ Template(const Template &) = delete;
+
+ Template &operator=(const Template &) = delete;
+
+ Template(Template &&Other) noexcept;
+
+ // Define this in the cpp file to work around ASTNode being an incomplete type.
+ ~Template();
+
+ Template &operator=(Template &&Other) noexcept;
+
+ void render(const llvm::json::Value &Data, llvm::raw_ostream &OS);
+
+ void registerPartial(std::string Name, std::string Partial);
+
+ void registerLambda(std::string Name, Lambda Lambda);
+
+ void registerLambda(std::string Name, SectionLambda Lambda);
+
+ // By default the Mustache Spec Specifies that HTML special characters
+ // should be escaped. This function allows the user to specify which
+ // characters should be escaped.
+ void overrideEscapeCharacters(DenseMap<char, std::string> Escapes);
+
+private:
+ StringMap<AstPtr> Partials;
+ StringMap<Lambda> Lambdas;
+ StringMap<SectionLambda> SectionLambdas;
+ DenseMap<char, std::string> Escapes;
+ AstPtr Tree;
+};
+} // namespace llvm::mustache
+
+#endif // LLVM_SUPPORT_MUSTACHE
diff --git a/llvm/lib/Support/CMakeLists.txt b/llvm/lib/Support/CMakeLists.txt
index 49a26a618de83..2754c97fce6c1 100644
--- a/llvm/lib/Support/CMakeLists.txt
+++ b/llvm/lib/Support/CMakeLists.txt
@@ -220,6 +220,7 @@ add_llvm_component_library(LLVMSupport
MD5.cpp
MSP430Attributes.cpp
MSP430AttributeParser.cpp
+ Mustache.cpp
NativeFormatting.cpp
OptimizedStructLayout.cpp
Optional.cpp
diff --git a/llvm/lib/Support/Mustache.cpp b/llvm/lib/Support/Mustache.cpp
new file mode 100644
index 0000000000000..1ef4f71cd7a12
--- /dev/null
+++ b/llvm/lib/Support/Mustache.cpp
@@ -0,0 +1,763 @@
+//===-- Mustache.cpp ------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#include "llvm/Support/Mustache.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <sstream>
+
+using namespace llvm;
+using namespace llvm::mustache;
+
+namespace {
+
+using Accessor = SmallVector<std::string>;
+
+static bool isFalsey(const json::Value &V) {
+ return V.getAsNull() || (V.getAsBoolean() && !V.getAsBoolean().value()) ||
+ (V.getAsArray() && V.getAsArray()->empty());
+}
+
+static Accessor splitMustacheString(StringRef Str) {
+ // We split the mustache string into an accessor.
+ // For example:
+ // "a.b.c" would be split into {"a", "b", "c"}
+ // We make an exception for a single dot which
+ // refers to the current context.
+ Accessor Tokens;
+ if (Str == ".") {
+ Tokens.emplace_back(Str);
+ return Tokens;
+ }
+ while (!Str.empty()) {
+ StringRef Part;
+ std::tie(Part, Str) = Str.split(".");
+ Tokens.emplace_back(Part.trim());
+ }
+ return Tokens;
+}
+} // namespace
+
+namespace llvm::mustache {
+
+class Token {
+public:
+ enum class Type {
+ Text,
+ Variable,
+ Partial,
+ SectionOpen,
+ SectionClose,
+ InvertSectionOpen,
+ UnescapeVariable,
+ Comment,
+ };
+
+ Token(std::string Str)
+ : TokenType(Type::Text), RawBody(std::move(Str)), TokenBody(RawBody),
+ AccessorValue({}), Indentation(0){};
+
+ Token(std::string RawBody, std::string TokenBody, char Identifier)
+ : RawBody(std::move(RawBody)), TokenBody(std::move(TokenBody)),
+ Indentation(0) {
+ TokenType = getTokenType(Identifier);
+ if (TokenType == Type::Comment)
+ return;
+ StringRef AccessorStr(this->TokenBody);
+ if (TokenType != Type::Variable)
+ AccessorStr = AccessorStr.substr(1);
+ AccessorValue = splitMustacheString(StringRef(AccessorStr).trim());
+ }
+
+ Accessor getAccessor() const { return AccessorValue; }
+
+ Type getType() const { return TokenType; }
+
+ void setIndentation(size_t NewIndentation) { Indentation = NewIndentation; }
+
+ size_t getIndentation() const { return Indentation; }
+
+ static Type getTokenType(char Identifier) {
+ switch (Identifier) {
+ case '#':
+ return Type::SectionOpen;
+ case '/':
+ return Type::SectionClose;
+ case '^':
+ return Type::InvertSectionOpen;
+ case '!':
+ return Type::Comment;
+ case '>':
+ return Type::Partial;
+ case '&':
+ return Type::UnescapeVariable;
+ default:
+ return Type::Variable;
+ }
+ }
+
+ Type TokenType;
+ // RawBody is the original string that was tokenized.
+ std::string RawBody;
+ // TokenBody is the original string with the identifier removed.
+ std::string TokenBody;
+ Accessor AccessorValue;
+ size_t Indentation;
+};
+
+class ASTNode {
+public:
+ enum Type {
+ Root,
+ Text,
+ Partial,
+ Variable,
+ UnescapeVariable,
+ Section,
+ InvertSection,
+ };
+
+ ASTNode(llvm::StringMap<AstPtr> &Partials, llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes)
+ : Partials(Partials), Lambdas(Lambdas), SectionLambdas(SectionLambdas),
+ Escapes(Escapes), Ty(Type::Root), Parent(nullptr),
+ ParentContext(nullptr) {}
+
+ ASTNode(std::string Body, ASTNode *Parent, llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes)
+ : Partials(Partials), Lambdas(Lambdas), SectionLambdas(SectionLambdas),
+ Escapes(Escapes), Ty(Type::Text), Body(std::move(Body)), Parent(Parent),
+ ParentContext(nullptr) {}
+
+ // Constructor for Section/InvertSection/Variable/UnescapeVariable Nodes
+ ASTNode(Type Ty, Accessor Accessor, ASTNode *Parent,
+ llvm::StringMap<AstPtr> &Partials, llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes)
+ : Partials(Partials), Lambdas(Lambdas), SectionLambdas(SectionLambdas),
+ Escapes(Escapes), Ty(Ty), Parent(Parent),
+ AccessorValue(std::move(Accessor)), ParentContext(nullptr) {}
+
+ void addChild(AstPtr Child) { Children.emplace_back(std::move(Child)); };
+
+ void setRawBody(std::string NewBody) { RawBody = std::move(NewBody); };
+
+ void setIndentation(size_t NewIndentation) { Indentation = NewIndentation; };
+
+ void render(const llvm::json::Value &Data, llvm::raw_ostream &OS);
+
+private:
+ void renderLambdas(const llvm::json::Value &Contexts, llvm::raw_ostream &OS,
+ Lambda &L);
+
+ void renderSectionLambdas(const llvm::json::Value &Contexts,
+ llvm::raw_ostream &OS, SectionLambda &L);
+
+ void renderPartial(const llvm::json::Value &Contexts, llvm::raw_ostream &OS,
+ ASTNode *Partial);
+
+ void renderChild(const llvm::json::Value &Context, llvm::raw_ostream &OS);
+
+ const llvm::json::Value *findContext();
+
+ StringMap<AstPtr> &Partials;
+ StringMap<Lambda> &Lambdas;
+ StringMap<SectionLambda> &SectionLambdas;
+ DenseMap<char, std::string> &Escapes;
+ Type Ty;
+ size_t Indentation = 0;
+ std::string RawBody;
+ std::string Body;
+ ASTNode *Parent;
+ // TODO: switch implementation to SmallVector<T>
+ std::vector<AstPtr> Children;
+ const Accessor AccessorValue;
+ const llvm::json::Value *ParentContext;
+};
+
+// A wrapper for arena allocator for ASTNodes
+AstPtr createRootNode(llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes) {
+ return std::make_unique<ASTNode>(Partials, Lambdas, SectionLambdas, Escapes);
+}
+
+AstPtr createNode(ASTNode::Type T, Accessor A, ASTNode *Parent,
+ llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes) {
+ return std::make_unique<ASTNode>(T, std::move(A), Parent, Partials, Lambdas,
+ SectionLambdas, Escapes);
+}
+
+AstPtr createTextNode(std::string Body, ASTNode *Parent,
+ llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes) {
+ return std::make_unique<ASTNode>(std::move(Body), Parent, Partials, Lambdas,
+ SectionLambdas, Escapes);
+}
+
+// Function to check if there is meaningful text behind.
+// We determine if a token has meaningful text behind
+// if the right of previous token contains anything that is
+// not a newline.
+// For example:
+// "Stuff {{#Section}}" (returns true)
+// vs
+// "{{#Section}} \n" (returns false)
+// We make an exception for when previous token is empty
+// and the current token is the second token.
+// For example:
+// "{{#Section}}"
+bool hasTextBehind(size_t Idx, const ArrayRef<Token> &Tokens) {
+ if (Idx == 0)
+ return true;
+
+ size_t PrevIdx = Idx - 1;
+ if (Tokens[PrevIdx].getType() != Token::Type::Text)
+ return true;
+
+ const Token &PrevToken = Tokens[PrevIdx];
+ StringRef TokenBody = StringRef(PrevToken.RawBody).rtrim(" \r\t\v");
+ return !TokenBody.ends_with("\n") && !(TokenBody.empty() && Idx == 1);
+}
+
+// Function to check if there's no meaningful text ahead.
+// We determine if a token has text ahead if the left of previous
+// token does not start with a newline.
+bool hasTextAhead(size_t Idx, const ArrayRef<Token> &Tokens) {
+ if (Idx >= Tokens.size() - 1)
+ return true;
+
+ size_t NextIdx = Idx + 1;
+ if (Tokens[NextIdx].getType() != Token::Type::Text)
+ return true;
+
+ const Token &NextToken = Tokens[NextIdx];
+ StringRef TokenBody = StringRef(NextToken.RawBody).ltrim(" ");
+ return !TokenBody.starts_with("\r\n") && !TokenBody.starts_with("\n");
+}
+
+bool requiresCleanUp(Token::Type T) {
+ // We must clean up all the tokens that could contain child nodes.
+ return T == Token::Type::SectionOpen || T == Token::Type::InvertSectionOpen ||
+ T == Token::Type::SectionClose || T == Token::Type::Comment ||
+ T == Token::Type::Partial;
+}
+
+// Adjust next token body if there is no text ahead.
+// For example:
+// The template string
+// "{{! Comment }} \nLine 2"
+// would be considered as no text ahead and should be rendered as
+// " Line 2"
+void stripTokenAhead(SmallVectorImpl<Token> &Tokens, size_t Idx) {
+ Token &NextToken = Tokens[Idx + 1];
+ StringRef NextTokenBody = NextToken.TokenBody;
+ // Cut off the leading newline which could be \n or \r\n.
+ if (NextTokenBody.starts_with("\r\n"))
+ NextToken.TokenBody = NextTokenBody.substr(2).str();
+ else if (NextTokenBody.starts_with("\n"))
+ NextToken.TokenBody = NextTokenBody.substr(1).str();
+}
+
+// Adjust previous token body if there no text behind.
+// For example:
+// The template string
+// " \t{{#section}}A{{/section}}"
+// would be considered as having no text ahead and would be render as
+// "A"
+// The exception for this is partial tag which requires us to
+// keep track of the indentation once it's rendered.
+void stripTokenBefore(SmallVectorImpl<Token> &Tokens, size_t Idx,
+ Token &CurrentToken, Token::Type CurrentType) {
+ Token &PrevToken = Tokens[Idx - 1];
+ StringRef PrevTokenBody = PrevToken.TokenBody;
+ StringRef Unindented = PrevTokenBody.rtrim(" \r\t\v");
+ size_t Indentation = PrevTokenBody.size() - Unindented.size();
+ if (CurrentType != Token::Type::Partial)
+ PrevToken.TokenBody = Unindented.str();
+ CurrentToken.setIndentation(Indentation);
+}
+
+// Simple tokenizer that splits the template into tokens.
+// The mustache spec allows {{{ }}} to unescape variables,
+// but we don't support that here. An unescape variable
+// is represented only by {{& variable}}.
+SmallVector<Token> tokenize(StringRef Template) {
+ SmallVector<Token> Tokens;
+ StringLiteral Open("{{");
+ StringLiteral Close("}}");
+ size_t Start = 0;
+ size_t DelimiterStart = Template.find(Open);
+ if (DelimiterStart == StringRef::npos) {
+ Tokens.emplace_back(Template.str());
+ return Tokens;
+ }
+ while (DelimiterStart != StringRef::npos) {
+ if (DelimiterStart != Start)
+ Tokens.emplace_back(Template.substr(Start, DelimiterStart - Start).str());
+ size_t DelimiterEnd = Template.find(Close, DelimiterStart);
+ if (DelimiterEnd == StringRef::npos)
+ break;
+
+ // Extract the Interpolated variable without delimiters.
+ size_t InterpolatedStart = DelimiterStart + Open.size();
+ size_t InterpolatedEnd = DelimiterEnd - DelimiterStart - Close.size();
+ std::string Interpolated =
+ Template.substr(InterpolatedStart, InterpolatedEnd).str();
+ std::string RawBody = Open.str() + Interpolated + Close.str();
+ Tokens.emplace_back(RawBody, Interpolated, Interpolated[0]);
+ Start = DelimiterEnd + Close.size();
+ DelimiterStart = Template.find(Open, Start);
+ }
+
+ if (Start < Template.size())
+ Tokens.emplace_back(Template.substr(Start).str());
+
+ // Fix up white spaces for:
+ // - open sections
+ // - inverted sections
+ // - close sections
+ // - comments
+ //
+ // This loop attempts to find standalone tokens and tries to trim out
+ // the surrounding whitespace.
+ // For example:
+ // if you have the template string
+ // {{#section}} \n Example \n{{/section}}
+ // The output should would be
+ // For example:
+ // \n Example \n
+ size_t LastIdx = Tokens.size() - 1;
+ for (size_t Idx = 0, End = Tokens.size(); Idx < End; ++Idx) {
+ Token &CurrentToken = Tokens[Idx];
+ Token::Type CurrentType = CurrentToken.getType();
+ // Check if token type requires cleanup.
+ bool RequiresCleanUp = requiresCleanUp(CurrentType);
+
+ if (!RequiresCleanUp)
+ continue;
+
+ // We adjust the token body if there's no text behind or ahead.
+ // A token is considered to have no text ahead if the right of the previous
+ // token is a newline followed by spaces.
+ // A token is considered to have no text behind if the left of the next
+ // token is spaces followed by a newline.
+ // eg.
+ // "Line 1\n {{#section}} \n Line 2 \n {{/section}} \n Line 3"
+ bool HasTextBehind = hasTextBehind(Idx, Tokens);
+ bool HasTextAhead = hasTextAhead(Idx, Tokens);
+
+ if ((!HasTextAhead && !HasTextBehind) || (!HasTextAhead && Idx == 0))
+ stripTokenAhead(Tokens, Idx);
+
+ if ((!HasTextBehind && !HasTextAhead) || (!HasTextBehind && Idx == LastIdx))
+ stripTokenBefore(Tokens, Idx, CurrentToken, CurrentType);
+ }
+ return Tokens;
+}
+
+// Custom stream to escape strings.
+class EscapeStringStream : public raw_ostream {
+public:
+ explicit EscapeStringStream(llvm::raw_ostream &WrappedStream,
+ DenseMap<char, std::string> &Escape)
+ : Escape(Escape), WrappedStream(WrappedStream) {
+ SetUnbuffered();
+ }
+
+protected:
+ void write_impl(const char *Ptr, size_t Size) override {
+ llvm::StringRef Data(Ptr, Size);
+ for (char C : Data) {
+ auto It = Escape.find(C);
+ if (It != Escape.end())
+ WrappedStream << It->getSecond();
+ else
+ WrappedStream << C;
+ }
+ }
+
+ uint64_t current_pos() const override { return WrappedStream.tell(); }
+
+private:
+ DenseMap<char, std::string> &Escape;
+ llvm::raw_ostream &WrappedStream;
+};
+
+// Custom stream to add indentation used to for rendering partials.
+class AddIndentationStringStream : public raw_ostream {
+public:
+ explicit AddIndentationStringStream(llvm::raw_ostream &WrappedStream,
+ size_t Indentation)
+ : Indentation(Indentation), WrappedStream(WrappedStream) {
+ SetUnbuffered();
+ }
+
+protected:
+ void write_impl(const char *Ptr, size_t Size) override {
+ llvm::StringRef Data(Ptr, Size);
+ SmallString<0> Indent;
+ Indent.resize(Indentation, ' ');
+ for (char C : Data) {
+ WrappedStream << C;
+ if (C == '\n')
+ WrappedStream << Indent;
+ }
+ }
+
+ uint64_t current_pos() const override { return WrappedStream.tell(); }
+
+private:
+ size_t Indentation;
+ llvm::raw_ostream &WrappedStream;
+};
+
+class Parser {
+public:
+ Parser(StringRef TemplateStr) : TemplateStr(TemplateStr) {}
+
+ AstPtr parse(llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ llvm::DenseMap<char, std::string> &Escapes);
+
+private:
+ void parseMustache(ASTNode *Parent, llvm::StringMap<AstPtr> &Partials,
+ llvm::StringMap<Lambda> &Lambdas,
+ llvm::StringMap<SectionLambda> &SectionLambdas,
+ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/132467
More information about the llvm-commits
mailing list