pluto-src 0.1.1+0.10.4

Sources of Pluto (Lua 5.4 dialect) and logic to build it.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#pragma once

#include <string>
#include <unordered_set>
#include <vector>

#include "fwd.hpp"
#include "UniquePtr.hpp"

NAMESPACE_SOUP
{
	class xml
	{
	public:
		static XmlMode MODE_XML;
		static XmlMode MODE_LAX_XML;
		static XmlMode MODE_HTML;

		[[nodiscard]] static UniquePtr<XmlTag> parseAndDiscardMetadata(const std::string& xml, const XmlMode& mode = MODE_XML);
		[[nodiscard]] static UniquePtr<XmlTag> parseAndDiscardMetadata(const char* begin, const char* end, const XmlMode& mode = MODE_XML);
		[[nodiscard]] static std::vector<UniquePtr<XmlNode>> parse(const std::string& xml, const XmlMode& mode = MODE_XML);
		[[nodiscard]] static std::vector<UniquePtr<XmlNode>> parse(const char* begin, const char* end, const XmlMode& mode = MODE_XML);
	private:
		[[nodiscard]] static UniquePtr<XmlNode> parseImpl(const char*& i, const char* end, const XmlMode& mode, int max_depth);
	};

	struct XmlNode
	{
		const bool is_text;

		constexpr XmlNode(bool is_text) noexcept
			: is_text(is_text)
		{
		}

		virtual ~XmlNode() = default;

		[[nodiscard]] std::string encode(const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		[[nodiscard]] std::string encodePretty(const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		void encodeAndAppendTo(std::string& str, const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		void encodePrettyAndAppendTo(std::string& str, const XmlMode& mode = xml::MODE_XML, unsigned depth = 0) const SOUP_EXCAL;

		// Type checks.
		[[nodiscard]] bool isTag() const noexcept;
		[[nodiscard]] bool isText() const noexcept;
		
		// Type casts; will throw if node is of different type.
		[[nodiscard]] XmlTag& asTag();
		[[nodiscard]] XmlText& asText();
		[[nodiscard]] const XmlTag& asTag() const;
		[[nodiscard]] const XmlText& asText() const;
	};

	struct XmlTag : public XmlNode
	{
		std::string name{};
		std::vector<UniquePtr<XmlNode>> children{};
		std::vector<std::pair<std::string, std::string>> attributes{};

		XmlTag() noexcept
			: XmlNode(false)
		{
		}

		[[nodiscard]] std::string encode(const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		[[nodiscard]] std::string encodePretty(const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		void encodeAndAppendTo(std::string& str, const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;
		void encodePrettyAndAppendTo(std::string& str, const XmlMode& mode = xml::MODE_XML, unsigned depth = 0) const SOUP_EXCAL;
		void encodeAttributesAndAppendTo(std::string& str, const XmlMode& mode = xml::MODE_XML) const SOUP_EXCAL;

		[[nodiscard]] bool hasAttribute(const std::string& name) const noexcept;
		[[nodiscard]] const std::string& getAttribute(const std::string& name) const;

		[[nodiscard]] XmlTag* findTag(const std::string& name_target);
	};

	struct XmlText : public XmlNode
	{
		std::string contents{};

		XmlText() noexcept
			: XmlNode(true)
		{
		}

		XmlText(std::string&& contents) noexcept;

		void encodeAndAppendTo(std::string& str) const SOUP_EXCAL;
	};

	struct XmlMode
	{
		// If not empty, `/>` is ignored. Instead, only contained tags are considered self-closing.
		std::unordered_set<std::string> self_closing_tags;

		// Allow attributes to be specified without a value.
		bool empty_attribute_syntax = false;

		// Allow attribute values to be bare strings.
		bool unquoted_attributes = false;
	};

	inline std::string XmlNode::encode(const XmlMode& mode) const SOUP_EXCAL
	{
		std::string str;
		encodeAndAppendTo(str, mode);
		return str;
	}

	inline std::string XmlNode::encodePretty(const XmlMode& mode) const SOUP_EXCAL
	{
		std::string str;
		encodePrettyAndAppendTo(str, mode);
		return str;
	}

	inline std::string XmlTag::encode(const XmlMode& mode) const SOUP_EXCAL
	{
		std::string str;
		encodeAndAppendTo(str, mode);
		return str;
	}

	inline std::string XmlTag::encodePretty(const XmlMode& mode) const SOUP_EXCAL
	{
		std::string str;
		encodePrettyAndAppendTo(str, mode);
		return str;
	}
}