hemplate

Redesign api for simplicity and flexibility

9 files changed, 141 insertions(+), 195 deletions(-)

diff --git a/ example/html.cpp b/ example/html.cpp

@@ -16,7 +16,7 @@ int main() }; std::cout << html::html {

comment("Hello this is a comment"),

comment {"Hello this is a comment"},

html::ul { ul_attrs, html::li {

@@ -28,7 +28,7 @@ int main() "Item 2", }, },

html::meta(),

html::hr {},

}; return 0;

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

@@ -27,26 +27,16 @@ public: { }

explicit feed(std::string_view xmlns, std::span<const element> children)

: element_builder(attributes(xmlns), children)

{

}

explicit feed(const is_element auto&... children) : feed(default_xmlns, children...) { }

explicit feed(std::span<const element> children)

: feed(default_xmlns, children)

{

}

};

using hemplate::blank;

using hemplate::comment; using hemplate::element; using hemplate::transform;

using hemplate::transparent;

using hemplate::xml; // clang-format off

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

@@ -56,6 +56,11 @@ public: void set(const attribute_list& list); void set(attribute attr);

bool empty() const

{

return m_attributes.empty() && m_class.empty() && m_style.empty();

}

explicit operator std::string() const { std::string res;

@@ -91,20 +96,6 @@ private: } // namespace hemplate template<>

struct std::formatter<hemplate::attribute>

{

static constexpr auto parse(std::format_parse_context& ctx)

{

return ctx.begin();

}

static auto format(const hemplate::attribute& type, std::format_context& ctx)

{

return std::format_to(ctx.out(), "{}", static_cast<std::string>(type));

}

};

template<>

struct std::formatter<hemplate::attribute_list> { static constexpr auto parse(std::format_parse_context& ctx)

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

@@ -11,11 +11,16 @@ namespace hemplate {

using comment = element_builder<"comment", element::Type::Comment>;

using transparent = element_builder<"transparent", element::Type::Transparent>;

class HEMPLATE_EXPORT comment : public element

{

public:

explicit comment(std::string_view data)

: element(std::format("<-- {} -->", data), "", "")

{

}

};

class HEMPLATE_EXPORT xml

: public element_builder<"xml", element::Type::Special>

class HEMPLATE_EXPORT xml : public element

{ public: static constexpr const auto default_version = "1.0";

@@ -31,13 +36,15 @@ public: std::string_view version = default_version, std::string_view encoding = default_encoding )

: element_builder(data(version, encoding))

: element(

std::format("<? {}?>", attribute_list {version, encoding}), "", ""

)

{ } }; template<std::ranges::forward_range R>

transparent transform(

blank transform(

const R& range, based::Procedure<std::ranges::range_value_t<R>> auto proc ) {

@@ -48,6 +55,7 @@ transparent transform( res.emplace_back(proc(elem)); }

return transparent {res};

return blank {res};

}

} // namespace hemplate

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

@@ -18,102 +18,64 @@ class element; template<typename T> concept is_element = std::derived_from<T, element>;

class HEMPLATE_EXPORT element : public attribute_list

class HEMPLATE_EXPORT element

{ public: enum class Type : uint8_t { Atomic, Boolean,

Comment,

Special,

Transparent,

};

const attribute_list& attributes() const { return *this; }

private:

template<based::string_literal Tag, element::Type MyType>

friend class element_builder;

Type m_type;

std::string m_tag;

std::string m_otag;

std::string m_ctag;

std::vector<element> m_children; std::string m_data;

explicit element(

Type type, std::string_view tag, const is_element auto&... children

)

: m_type(type)

, m_tag(tag)

, m_children(std::initializer_list<element> {children...})

{

}

void render_children(std::ostream& out, std::size_t indent_value) const;

void render(std::ostream& out, std::size_t indent_value) const;

explicit element(Type type, std::string_view tag, std::string_view data)

: m_type(type)

, m_tag(tag)

, m_data(data)

public:

explicit element(std::string_view open_tag)

: m_otag(open_tag)

{ } explicit element(

Type type, std::string_view tag, std::span<const element> children

std::string_view open_tag,

std::string_view close_tag,

std::string_view data

)

: m_type(type)

, m_tag(tag)

, m_children(children.begin(), children.end())

: m_otag(open_tag)

, m_ctag(close_tag)

, m_data(data)

{ } explicit element(

Type type,

std::string_view tag,

attribute_list attributes,

std::string_view open_tag,

std::string_view close_tag,

const is_element auto&... children )

: attribute_list(std::move(attributes))

, m_type(type)

, m_tag(tag)

: m_otag(open_tag)

, m_ctag(close_tag)

, m_children(std::initializer_list<element> {children...}) { } explicit element(

Type type,

std::string_view tag,

attribute_list attributes,

std::string_view data

)

: attribute_list(std::move(attributes))

, m_type(type)

, m_tag(tag)

, m_data(data)

{

}

explicit element(

Type type,

std::string_view tag,

attribute_list attributes,

std::string_view open_tag,

std::string_view close_tag,

std::span<const element> children )

: attribute_list(std::move(attributes))

, m_type(type)

, m_tag(tag)

, m_children(children.begin(), children.end())

: m_otag(open_tag)

, m_ctag(close_tag)

, m_children(std::begin(children), std::end(children))

{ }

void render_atomic(std::ostream& out, std::size_t indent_value) const;

void render_boolean(std::ostream& out, std::size_t indent_value) const;

void render_comment(std::ostream& out, std::size_t indent_value) const;

void render_special(std::ostream& out, std::size_t indent_value) const;

void render_children(std::ostream& out, std::size_t indent_value) const;

void render(std::ostream& out, std::size_t indent_value) const;

public:

explicit operator std::string() const { std::stringstream ss;

@@ -129,24 +91,89 @@ public: }; template<based::string_literal Tag, element::Type MyType>

class HEMPLATE_EXPORT element_builder : public element

class element_builder;

template<based::string_literal Tag>

class HEMPLATE_EXPORT element_builder<Tag, element::Type::Boolean>

: public element

{

static auto close() { return std::format("</{}>", Tag.data()); }

static auto open(const attribute_list& attrs = {})

{

return attrs.empty() ? std::format("<{}>", Tag.data())

: std::format("<{} {}>", Tag.data(), attrs);

}

public:

// NOLINTBEGIN *-no-array-decay

template<typename... Args>

explicit element_builder(Args&&... args)

: element(MyType, Tag.data(), std::forward<Args>(args)...)

explicit element_builder(std::string_view data)

: element(open(), close(), data)

{

}

explicit element_builder(const is_element auto&... children)

: element(open(), close(), children...)

{

}

explicit element_builder(std::span<const element> children)

: element(open(), close(), children)

{

}

explicit element_builder(const attribute_list& attrs, std::string_view data)

: element(open(attrs), close(), data)

{

}

explicit element_builder(

const attribute_list& attrs, const is_element auto&... children

)

: element(open(attrs), close(), children...)

{

}

explicit element_builder(

const attribute_list& attrs, std::span<const element> children

)

: element(open(attrs), close(), children)

{

}

};

template<based::string_literal Tag>

class HEMPLATE_EXPORT element_builder<Tag, element::Type::Atomic>

: public element

{

static auto open(const attribute_list& attrs = {})

{

return attrs.empty() ? std::format("<{} />", Tag.data())

: std::format("<{} {} />", Tag.data(), attrs);

}

public:

explicit element_builder(const attribute_list& list = {})

: element(open(list))

{

}

};

class HEMPLATE_EXPORT blank : public element

{

public:

explicit blank(std::string_view data)

: element("", "", data)

{

}

explicit blank(const is_element auto&... children)

: element("", "", children...)

{ }

template<typename... Args>

explicit element_builder(attribute_list list, Args&&... args)

: element(

MyType, Tag.data(), std::move(list), std::forward<Args>(args)...

)

explicit blank(std::span<const element> children)

: element("", "", children)

{ }

// NOLINTEND *-no-array-decay

}; } // namespace hemplate

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

@@ -5,17 +5,17 @@ namespace hemplate::html {

using hemplate::blank;

using hemplate::comment; using hemplate::element; using hemplate::transform;

using hemplate::transparent;

using hemplate::xml;

class doctype : public element_builder<"DOCTYPE", element::Type::Special>

class doctype : public element

{ public: explicit doctype()

: element_builder("!DOCTYPE html")

: element("<!DOCTYPE html>", "", "")

{ } };

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

@@ -33,24 +33,10 @@ public: { }

explicit rss(

std::string_view version,

std::string_view xmlns,

std::span<const element> children

)

: element_builder(attributes(version, xmlns), children)

{

}

explicit rss(const is_element auto&... children) : rss(default_version, default_xmlns, children...) { }

explicit rss(std::span<const element> children)

: rss(default_version, default_xmlns, children)

{

}

}; class HEMPLATE_EXPORT atomLink // NOLINT *-identifier-naming

@@ -84,10 +70,9 @@ public: explicit atomLink( std::string_view rel, std::string_view type,

attribute_list attrs,

std::span<const element> children

const is_element auto&... children

)

: element_builder(attributes(attrs, rel, type), children)

: atomLink(rel, type, {}, children...)

{ }

@@ -96,26 +81,16 @@ public: { }

explicit atomLink(attribute_list attrs, std::span<const element> children)

: atomLink(default_rel, default_type, std::move(attrs), children)

{

}

explicit atomLink(const is_element auto&... children) : atomLink({}, children...) { }

explicit atomLink(std::span<const element> children)

: atomLink({}, children)

{

}

};

using hemplate::blank;

using hemplate::comment; using hemplate::element; using hemplate::transform;

using hemplate::transparent;

using hemplate::xml; // clang-format off

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

@@ -25,26 +25,16 @@ public: { }

explicit urlset(std::string_view xmlns, std::span<const element> children)

: element_builder(attributes(xmlns), children)

{

}

explicit urlset(const is_element auto&... children) : urlset(default_xmlns, children...) { }

explicit urlset(std::span<const element> children)

: urlset(default_xmlns, children)

{

}

};

using hemplate::blank;

using hemplate::comment; using hemplate::element; using hemplate::transform;

using hemplate::transparent;

using hemplate::xml; // clang-format off

diff --git a/ source/element.cpp b/ source/element.cpp

@@ -1,4 +1,3 @@

#include <format>

#include <ostream> #include <string>

@@ -7,24 +6,6 @@ namespace hemplate {

void element::render_comment(std::ostream& out, std::size_t indent_value) const

{

const std::string indent(indent_value, ' ');

out << indent << "<!-- " << m_data << " -->\n";

}

void element::render_atomic(std::ostream& out, std::size_t indent_value) const

{

const std::string indent(indent_value, ' ');

out << indent << std::format("<{} {}/>\n", m_tag, attributes());

}

void element::render_special(std::ostream& out, std::size_t indent_value) const

{

const std::string indent(indent_value, ' ');

out << indent << std::format("<{}>\n", m_data);

}

void element::render_children(std::ostream& out, std::size_t indent_value) const { for (const auto& child : m_children) {

@@ -36,49 +17,33 @@ void element::render(std::ostream& out, std::size_t indent_value) const { const std::string indent(indent_value, ' ');

switch (m_type) {

case Type::Atomic:

render_atomic(out, indent_value);

return;

case Type::Comment:

render_comment(out, indent_value);

return;

case Type::Special:

render_special(out, indent_value);

return;

case Type::Transparent:

if (m_otag.empty()) {

if (!m_data.empty()) {

out << indent << m_data << '\n';

} else {

render_children(out, indent_value);

return;

default:

break;

}

return;

}

if (m_tag.empty()) {

out << indent << m_data << '\n';

if (m_ctag.empty()) {

out << indent << m_otag << '\n';

return; } if (!m_data.empty()) {

out << indent << std::format("<{} {}>\n", m_tag, attributes());

if (!m_children.empty()) {

render_children(out, indent_value + 2);

} else {

out << indent << " " << m_data << '\n';

}

out << indent << std::format("</{}>\n", m_tag);

out << indent << m_otag << m_data << m_ctag << '\n';

return; } if (!m_children.empty()) {

out << indent << std::format("<{} {}>\n", m_tag, attributes());

out << indent << m_otag << '\n';

render_children(out, indent_value + 2);

out << indent << std::format("</{}>\n", m_tag);

out << m_ctag << '\n';

return; }

out << indent << std::format("<{0} {1}></{0}>\n", m_tag, attributes());

out << indent << m_otag << m_ctag << '\n';

} } // namespace hemplate