hemplate

Add attributes and various constructors * Working render for all different cases

8 files changed, 227 insertions(+), 28 deletions(-)

diff --git a/ CMakeLists.txt b/ CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake) project( hemplate

VERSION 0.1.2

VERSION 0.1.3

DESCRIPTION "Simple HTML template engine" HOMEPAGE_URL "https://git.dimitrijedobrota.com/hemplate.git" LANGUAGES CXX

@@ -18,6 +18,7 @@ include(cmake/variables.cmake) add_library( hemplate_hemplate source/element.cpp

source/attribute.cpp

) add_library(hemplate::hemplate ALIAS hemplate_hemplate)

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

@@ -0,0 +1,70 @@

#pragma once

#include <string>

#include <vector>

#include "hemplate/hemplate_export.hpp"

#include "hemplate/streamable.hpp"

namespace hemplate

{

class HEMPLATE_EXPORT attribute : public streamable

{

public:

attribute() = default;

attribute(const attribute&) = default;

attribute(attribute&&) = default;

attribute& operator=(const attribute&) = default;

attribute& operator=(attribute&&) = default;

~attribute() override = default;

attribute(std::string name) // NOLINT

: m_name(std::move(name))

{

}

attribute(std::string name, std::string value) // NOLINT

: m_name(std::move(name))

, m_value(std::move(value))

{

}

bool operator!=(const attribute& rhs) const;

bool operator==(const attribute& rhs) const;

const std::string& get_name() const { return m_name; }

const std::string& get_value() const { return m_value; }

void set_name(const std::string& name) { m_name = name; }

void set_value(const std::string& value) { m_value = value; }

void render(std::ostream& out) const override;

private:

std::string m_name;

std::string m_value;

};

class HEMPLATE_EXPORT attributeList : public streamable

{

public:

attributeList() = default;

attributeList(const attributeList&) = default;

attributeList(attributeList&&) = default;

attributeList& operator=(const attributeList&) = default;

attributeList& operator=(attributeList&&) = default;

~attributeList() override = default;

attributeList& set(const std::string& name);

attributeList& set(const std::string& name, const std::string& value);

bool empty() const { return m_attributes.empty(); }

void render(std::ostream& out) const override;

private:

std::vector<attribute> m_attributes;

};

} // namespace hemplate

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

@@ -4,6 +4,7 @@ #include <string> #include <vector>

#include "hemplate/attribute.hpp"

#include "hemplate/hemplate_export.hpp" #include "hemplate/streamable.hpp"

@@ -44,8 +45,13 @@ public: Boolean, };

explicit element(std::string data, Type type)

: m_data(std::move(data))

explicit element(attributeList attributes,

elementList embedded,

std::string data,

Type type)

: m_attributes(std::move(attributes))

, m_embeded(std::move(embedded))

, m_data(std::move(data))

, m_type(type) { }

@@ -59,23 +65,32 @@ public: Type get_type() const { return m_type; } std::string get_data() const { return m_data; } const elementList& get_embeded() const { return m_embeded; }

const attributeList& get_attributes() const { return m_attributes; }

virtual bool get_state() const { return false; }

virtual const char* get_name() const = 0;

void set_data(const std::string& data) { m_data = data; } void set_embedded(const elementList& embed) { m_embeded = embed; }

void set_attributes(const attributeList& attrs) { m_attributes = attrs; }

virtual void tgl_state() const {}

element& add(const element& elem); element& add(std::unique_ptr<element> elem);

virtual const char* get_name() const = 0;

element& set(const std::string& name);

element& set(const std::string& name, const std::string& value);

virtual std::unique_ptr<element> clone() const = 0; void render(std::ostream& out) const override; private:

attributeList m_attributes;

elementList m_embeded;

std::string m_data; Type m_type;

elementList m_embeded;

}; } // namespace hemplate

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

@@ -10,17 +10,22 @@ template<typename Tag> class HEMPLATE_EXPORT elementAtomic : public element { public:

elementAtomic()

: element("", Type::Atomic)

{

}

elementAtomic(const elementAtomic&) = default; elementAtomic(elementAtomic&&) noexcept = default; elementAtomic& operator=(const elementAtomic&) = default; elementAtomic& operator=(elementAtomic&&) noexcept = default; ~elementAtomic() override = default;

elementAtomic()

: element({}, {}, "", Type::Atomic)

{

}

elementAtomic(attributeList attributes) // NOLINT

: element(std::move(attributes), {}, "", Type::Atomic)

{

}

const char* get_name() const override { return Tag::get_name(); } std::unique_ptr<element> clone() const override

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

@@ -10,23 +10,46 @@ template<typename Tag> class HEMPLATE_EXPORT elementBoolean : public element { public:

elementBoolean(const elementBoolean&) = default;

elementBoolean(elementBoolean&&) noexcept = default;

elementBoolean& operator=(const elementBoolean&) = default;

elementBoolean& operator=(elementBoolean&&) noexcept = default;

~elementBoolean() override = default;

elementBoolean()

: element("", Type::Boolean)

: element({}, {}, "", Type::Boolean)

{ }

elementBoolean(const std::string& text) // NOLINT

: element(text, Type::Boolean)

elementBoolean(std::string text) // NOLINT

: element({}, {}, std::move(text), Type::Boolean)

{ }

elementBoolean(const elementBoolean&) = default;

elementBoolean(elementBoolean&&) noexcept = default;

elementBoolean& operator=(const elementBoolean&) = default;

elementBoolean& operator=(elementBoolean&&) noexcept = default;

~elementBoolean() override = default;

elementBoolean(attributeList attributes) // NOLINT

: element(std::move(attributes), {}, "", Type::Boolean)

{

}

elementBoolean(elementList embedded) // NOLINT

: element({}, std::move(embedded), "", Type::Boolean)

{

}

elementBoolean(std::string text, attributeList attributes)

: element(std::move(attributes), {}, std::move(text), Type::Boolean)

{

}

elementBoolean(attributeList attributes, elementList embedded)

: element(std::move(attributes), std::move(embedded), "", Type::Boolean)

{

}

const char* get_name() const override { return Tag::get_name(); }

bool get_state() const override { return m_state; }

void tgl_state() const override { m_state = !m_state; }

std::unique_ptr<element> clone() const override {

@@ -34,6 +57,10 @@ public: } private:

static bool m_state; // NOLINT

};

template<typename Tag>

bool elementBoolean<Tag>::m_state = false; // NOLINT

} // namespace hemplate

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

@@ -0,0 +1,41 @@

#include "hemplate/attribute.hpp"

namespace hemplate

{

bool attribute::operator!=(const attribute& rhs) const

{

return !(*this == rhs);

}

bool attribute::operator==(const attribute& rhs) const

{

return m_name == rhs.m_name && m_value == rhs.m_value;

}

void attribute::render(std::ostream& out) const

{

out << get_name() << "=\"" << get_value() << "\"";

}

attributeList& attributeList::set(const std::string& name)

{

m_attributes.emplace_back(name);

return *this;

}

attributeList& attributeList::set(const std::string& name,

const std::string& value)

{

m_attributes.emplace_back(name, value);

return *this;

}

void attributeList::render(std::ostream& out) const

{

for (const auto& attr : m_attributes) {

out << attr << ' ';

}

}

} // namespace hemplate

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

@@ -15,24 +15,55 @@ element& element::add(std::unique_ptr<element> elem) return *this; }

element& element::set(const std::string& name)

{

m_attributes.set(name);

return *this;

}

element& element::set(const std::string& name, const std::string& value)

{

m_attributes.set(name, value);

return *this;

}

void element::render(std::ostream& out) const {

if (get_type() == Type::Boolean && m_data.empty()) {

out << '<' << get_name() << '>';

const auto open_tag = [this, &out](bool atomic)

{

out << '<' << get_name();

if (!m_attributes.empty()) {

out << ' ';

m_attributes.render(out);

}

out << (atomic ? " />" : ">");

};

m_embeded.render(out);

const auto close_tag = [this, &out]() { out << "</" << get_name() << '>'; };

out << "</" << get_name() << '>';

} else {

out << '<' << get_name() << '>';

if (m_type == Type::Atomic) {

open_tag(true);

return;

}

if (!m_data.empty()) {

open_tag(false);

if (!m_embeded.empty()) { m_embeded.render(out); } else { out << m_data; }

close_tag();

return;

}

out << "</" << get_name() << '>';

if (m_embeded.empty()) {

tgl_state();

get_state() ? open_tag(false) : close_tag();

} else {

open_tag(false);

m_embeded.render(out);

close_tag();

} }

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

@@ -4,10 +4,19 @@ int main() {

using namespace hemplate; // NOLINT

using namespace hemplate; // NOLINT

std::cout << ul("Won't see").add(li("Item 1")).add(li("Item 2")) << std::endl;

attributeList li_attrs;

li_attrs.set("class", "main_li");

std::cout << html() << std::endl;

std::cout << ul("Won't see")

.set("id", "main_ul")

.add(li("Item 1", li_attrs))

.add(li("Item 2", li_attrs))

<< std::endl;

std::cout << meta() << std::endl;

std::cout << html() << std::endl;

return 0; }