hemplate

Simple XML template engine
git clone git://git.dimitrijedobrota.com/hemplate.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit cb6446371e20af7b6f6b6637da005fa73ebbe589
parent d6ac3a263b2f1141f8c28b6c29ae246ba8b58ad4
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Fri, 2 May 2025 20:53:15 +0200

Inline element for cleaner output

* Elements with only one string will be printed in a line

Diffstat:
M include/hemplate/element.hpp | ++++++++++++++++++++++++++++++++++++++ ------------
M test/source/classes_test.cpp | ++++++++++++++++++++++++++++++ -------------
M test/source/element_test.cpp | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ----------

3 files changed, 210 insertions(+), 44 deletions(-)

diff --git a/ include/hemplate/element.hpp b/ include/hemplate/element.hpp

@@ -35,20 +35,40 @@ class HEMPLATE_EXPORT element_base

using child_t = std::variant<element_base, std::string>;
std::vector<child_t> m_cdn;

void add(std::ranges::forward_range auto range)
void add(std::string_view data) { m_cdn.emplace_back(std::string(data)); }

void add(element_base base_elem)
{
if (base_elem.m_otag.empty()) {
add(std::move(base_elem.m_cdn));
return;
}

m_cdn.emplace_back(std::move(base_elem));
}

void add(std::vector<child_t> children)
{
for (auto& range_elem : children) {
std::visit(
[this](auto&& elem)
{
add(elem);
},
std::move(range_elem)
);
}
}

void add(const std::ranges::forward_range auto& range)
requires(!std::constructible_from<std::string_view, decltype(range)>)
{
m_cdn.reserve(std::size(m_cdn) + std::size(range));
m_cdn.insert(
std::end(m_cdn),
std::make_move_iterator(std::begin(range)),
std::make_move_iterator(std::end(range))
);
for (auto& elem : range) {
add(std::move(elem));
}
}

void add(std::string_view data) { m_cdn.emplace_back(std::string(data)); }
void add(element_base elem) { m_cdn.emplace_back(std::move(elem)); }

template<typename... Args>
explicit element_base(
std::string_view open_tag, std::string_view close_tag, Args&&... args

@@ -89,9 +109,15 @@ class HEMPLATE_EXPORT element_base

return;
}

out << indent << m_otag << '\n';
render_children(out, indent_value + 2);
out << indent << m_ctag << '\n';
if (m_cdn.size() == 1 && std::holds_alternative<std::string>(m_cdn.front()))
{
out << indent << m_otag << std::get<std::string>(m_cdn.front()) << m_ctag
<< '\n';
} else {
out << indent << m_otag << '\n';
render_children(out, indent_value + 2);
out << indent << m_ctag << '\n';
}
}

public:

diff --git a/ test/source/classes_test.cpp b/ test/source/classes_test.cpp

@@ -42,17 +42,34 @@ TEST_CASE("transform", "[classes/transform]")

using tag = hemplate::element_boolean<"t">;
using child = hemplate::element_boolean<"c">;

const std::vector<std::string> vec = {"1", "2"};
const auto t = tag {hemplate::transform(
vec,
[](const auto& e)
{
return child {e};
}
)};

REQUIRE(
std::string(t)
== "<t>\n <c>\n 1\n </c>\n <c>\n 2\n </c>\n</t>\n"
);
SECTION("direct")
{
const std::vector<std::string> vec = {"1", "2"};
const auto t = tag {hemplate::transform(
vec,
[](const auto& e)
{
return child {e};
}
)};

REQUIRE(
std::string(t)
== "<t>\n <c>1</c>\n <c>2</c>\n</t>\n"
);
}

SECTION("indirect")
{
const std::vector<std::string> vec = {"1", "2"};
const auto t = tag {hemplate::transform(
vec,
[](const auto& e)
{
return hemplate::element {e};
}
)};

REQUIRE(std::string(t) == "<t>\n 1\n 2\n</t>\n");
}
}

diff --git a/ test/source/element_test.cpp b/ test/source/element_test.cpp

@@ -27,14 +27,14 @@ TEST_CASE("boolean", "[element]")

{
const auto t = tag {"text"};

REQUIRE(std::string(t) == "<tag>\n text\n</tag>\n");
REQUIRE(std::string(t) == "<tag>text</tag>\n");
}

SECTION("attribute data")
{
const auto t = tag {{{"attr", "val"}}, "text"};

REQUIRE(std::string(t) == "<tag attr=\"val\">\n text\n</tag>\n");
REQUIRE(std::string(t) == "<tag attr=\"val\">text</tag>\n");
}

SECTION("child")

@@ -64,9 +64,7 @@ TEST_CASE("boolean", "[element]")

child {"text"},
};

REQUIRE(
std::string(t) == "<tag>\n <child>\n text\n </child>\n</tag>\n"
);
REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("attribute child data")

@@ -77,8 +75,7 @@ TEST_CASE("boolean", "[element]")

};

REQUIRE(
std::string(t)
== "<tag attr=\"val\">\n <child>\n text\n </child>\n</tag>\n"
std::string(t) == "<tag attr=\"val\">\n <child>text</child>\n</tag>\n"
);
}

@@ -89,6 +86,12 @@ TEST_CASE("boolean", "[element]")


REQUIRE(std::string(t) == "<tag>\n hello\n world\n</tag>\n");
}

SECTION("tag element elemetn tag")
{
const auto t = tag {element {element {tag {}}}};
REQUIRE(std::string(t) == "<tag>\n <tag>\n </tag>\n</tag>\n");
}
}

TEST_CASE("atomic", "[element]")

@@ -112,6 +115,7 @@ TEST_CASE("atomic", "[element]")


TEST_CASE("element", "[element]")
{
using tag = element_boolean<"tag">;
using child = element_boolean<"child">;

SECTION("empty")

@@ -128,39 +132,158 @@ TEST_CASE("element", "[element]")

REQUIRE(std::string(t) == "text\n");
}

SECTION("child")
SECTION("tag")
{
const auto t = element {
child {},
tag {},
};

REQUIRE(std::string(t) == "<child>\n</child>\n");
REQUIRE(std::string(t) == "<tag>\n</tag>\n");
}

SECTION("child element")
SECTION("tag element")
{
const auto t = child {
const auto t = tag {
element {},
};

REQUIRE(std::string(t) == "<child>\n</child>\n");
REQUIRE(std::string(t) == "<tag>\n</tag>\n");
}

SECTION("element child data")
SECTION("element tag")
{
const auto t = element {
child {"text"},
tag {},
};

REQUIRE(std::string(t) == "<child>\n text\n</child>\n");
REQUIRE(std::string(t) == "<tag>\n</tag>\n");
}

SECTION("child element data")
SECTION("element tag data")
{
const auto t = child {
const auto t = element {
tag {"text"},
};

REQUIRE(std::string(t) == "<tag>text</tag>\n");
}

SECTION("tag element data")
{
const auto t = tag {
element {"text"},
};

REQUIRE(std::string(t) == "<tag>text</tag>\n");
}

SECTION("tag element data")
{
const auto t = tag {
element {"text"},
};

REQUIRE(std::string(t) == "<child>\n text\n</child>\n");
REQUIRE(std::string(t) == "<tag>text</tag>\n");
}

SECTION("element tag child data")
{
const auto t = element {
tag {
child {
"text",
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("element tag element child data")
{
const auto t = element {
tag {
element {
child {
"text",
},
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("element tag child element data")
{
const auto t = element {
tag {
child {
element {
"text",
},
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("element tag element child element data")
{
const auto t = element {
tag {
element {
child {
element {
"text",
},
},
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("tag element child data")
{
const auto t = tag {
element {
child {
"text",
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("tag child element data")
{
const auto t = tag {
child {
element {
"text",
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}

SECTION("tag element child element data")
{
const auto t = tag {
element {
child {
element {
"text",
},
},
},
};

REQUIRE(std::string(t) == "<tag>\n <child>text</child>\n</tag>\n");
}
}