Manager+Doc: Make package tracking more flexible, allow custom filenames

Extending the type compatibility is done with an easy to use API.

.clang-format

@@ -17,6 +17,7 @@ AllowAllParametersOfDeclarationOnNextLine:       false
 AllowShortLambdasOnASingleLine:                  All
 
 AlwaysBreakTemplateDeclarations:                 Yes
+IndentPPDirectives:                              BeforeHash
 
 BraceWrapping:
   AfterEnum:                                     false
@@ -32,7 +33,7 @@ SpaceAfterTemplateKeyword:                       false
 SpaceInEmptyBlock:                               false
 NamespaceIndentation:                            None
 FixNamespaceComments:                            true
-Standard:                                        c++17
+Standard:                                        c++20
 TabWidth:                                        4
 UseTab:                                          AlignWithSpaces
 ...

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/ruc"]
+	path = vendor/ruc
+	url = https://github.com/Riyyi/ruc

CMakeLists.txt

@@ -4,6 +4,9 @@
 # Set project name
 set(PROJECT "manafiles")
 
+# Unit tests
+option(MANAFILES_BUILD_TESTS "Build the Manafiles test programs" ON)
+
 # ------------------------------------------
 
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
@@ -15,7 +18,7 @@ include(GNUInstallDirs)
 # ------------------------------------------
 # Setup C++ compiler
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
@@ -50,29 +53,23 @@ endif()
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # ------------------------------------------
-# Configure source
+# Library
 
-# Define include files
+set(RUC_BUILD_TESTS OFF)
-include_directories(
+add_subdirectory("vendor/ruc")
-	"src"
+
-	"test"
+# ------------------------------------------
-)
+# Application target
 
 # Define source files
 file(GLOB_RECURSE PROJECT_SOURCES "src/*.cpp")
 set(PROJECT_SOURCES ${PROJECT_SOURCES})
 
-# Define test source files
-file(GLOB_RECURSE TEST_SOURCES "test/*.cpp")
-file(GLOB_RECURSE MAIN_SOURCES "src/*.cpp")
-set(TEST_SOURCES ${TEST_SOURCES} ${MAIN_SOURCES})
-list(REMOVE_ITEM TEST_SOURCES "${CMAKE_SOURCE_DIR}/src/main.cpp")
-
-# ------------------------------------------
-# Application target
-
 add_executable(${PROJECT} ${PROJECT_SOURCES})
-target_link_libraries(${PROJECT})
+target_include_directories(${PROJECT} PRIVATE
+	"src"
+	"vendor/ruc/src")
+target_link_libraries(${PROJECT} ruc)
 
 install(TARGETS ${PROJECT}
 	DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -88,8 +85,21 @@ add_dependencies(run ${PROJECT})
 # ------------------------------------------
 # Unit test target
 
-add_executable(test ${TEST_SOURCES})
+if (MANAFILES_BUILD_TESTS)
-target_link_libraries(test)
+	# Define test source files
+	file(GLOB_RECURSE TEST_SOURCES "test/*.cpp")
+	set(TEST_SOURCES ${TEST_SOURCES} ${PROJECT_SOURCES})
+	list(REMOVE_ITEM TEST_SOURCES "${CMAKE_SOURCE_DIR}/src/main.cpp")
+
+	add_executable(${PROJECT}-unit-test ${TEST_SOURCES})
+	target_include_directories(${PROJECT}-unit-test PRIVATE
+		"src"
+		"test"
+		"vendor/ruc/src"
+		"vendor/ruc/test")
+	target_link_libraries(${PROJECT}-unit-test ruc)
+	target_link_libraries(${PROJECT}-unit-test ruc-test)
+endif()
 
 # ------------------------------------------
 # Man page target

README.org

@@ -16,7 +16,7 @@ Config file and package tracking utility.
 
 If you are using *Arch Linux*, you can install the AUR package [[https://aur.archlinux.org/packages/manafiles-git/][manafiles-git]].
 
-Alternatively, you will have to [[#building][build from source]].
+Alternatively, you will have to [[#compiling][build from source]].
 
 *** Configuration
 
@@ -66,6 +66,7 @@ The system patterns from the example config:
 "systemPatterns": [
 	"/boot/",
 	"/etc/",
+	"/usr/lib/",
 	"/usr/share/"
 ]
 #+END_SRC
@@ -85,21 +86,29 @@ or uncomments them depending on the machine's configuration. Such a block looks
 like this:
 
 #+BEGIN_SRC shell-script
-# >>> distro=arch hostname=arch-desktop user=anon
+# >>> distro=arch hostname=arch-desktop user=anon session=xorg
 export PATH="$PATH:$HOME/.local/bin"
 # <<<
 #+END_SRC
 
-This block uses all of the supported configurations, ~distro~, ~hostname~ and
+This block uses all of the supported configurations, ~distro~, ~hostname~,
- ~user~. These can be used in any combination and order.
+~user~ and ~session~. These can be used in any combination and order.
 
 If *all* of the given configurations match, manafiles will make sure that the
 contents of the block are uncommented. If *any* of them do *not* match, then
 manafiles will make sure that the contents of the block are commented.
 
-** Building
+***** Usable values for the configurations
 
-*** Build dependencies
+| distro | session |
+|--------+---------|
+| arch   | xorg    |
+| debian | wayland |
+| ubuntu |         |
+
+** Compiling
+
+*** Dependencies
 
 - ~gcc-libs~
 - (make) ~cmake~
@@ -111,17 +120,46 @@ manafiles will make sure that the contents of the block are commented.
 
 The optional requirements are for the package tracking functionality.
 
-*** Build compilation
+*** Building
+
+To get the sources from the repository, run the following commands:
+
+#+BEGIN_SRC shell-script
+$ git clone https://github.com/riyyi/manafiles
+$ cd manafiles
+$ git submodule init
+$ git submodule update
+#+END_SRC
+
+or
+
+#+BEGIN_SRC shell-script
+$ git clone --recursive https://github.com/riyyi/manafiles
+$ cd manafiles
+#+END_SRC
+
+**** Compiling
+
+To compile, run the following commands:
 
 #+BEGIN_SRC shell-script
 $ mkdir build
 $ cd build
 $ cmake ..
 $ make
-#+END_SRC
+# Optional. This will install the manafiles executable in /usr/bin
-
-*** Build installation
-
-#+BEGIN_SRC shell-script
 $ sudo make install
 #+END_SRC
+
+*** Uninstalling
+
+To uninstall, run the following commands:
+
+*Warning*: ~make uninstall~ will try to delete all files listed in the
+~install_manifest.txt~ file inside your ~build~ folder. Make sure you first
+check that it won't delete any important files.
+
+#+BEGIN_SRC shell-script
+$ cd build
+$ sudo make uninstall
+#+END_SRC

doc/manafiles.1

@@ -1,4 +1,4 @@
-.TH MANAFILES 1 "2022-01-29" "manafiles 0.5" "User Commands"
+.TH MANAFILES 1 "2025-02-02" "manafiles 0.6" "User Commands"
 
 .SH NAME
 manafiles \- config file and package tracking utility
@@ -31,7 +31,7 @@ See File Options below.
 .TP
 .BR \-P ", " \-\-package
 Operate on packages. \
-This operation allows you to track installed packages and reinstall them. \
+This operation allows tracking installed packages and reinstalling them. \
 In the first case, if no package names are provided in the command line, all packages will be selected. \
 See Package Options below.
 
@@ -67,8 +67,10 @@ Install all AUR packages of the stored list.
 Install all official packages of the stored list.
 
 .TP
-.BR \-s ", " \-\-store
+.BR \-s ", " \-\-search
-Stores a list of all installed packages on the system.
+Search each locally-installed package for names via a partial match. \
+When including multiple search terms, all packages with names matching any of those terms are returned. \
+If the \fB-s\fR option is ommited, packages names are filtered via a full match.
 
 .SH EXAMPLES
 Usage examples:

doc/manafiles.json

@@ -10,6 +10,7 @@
 	"systemPatterns": [
 		"/boot/",
 		"/etc/",
+		"/usr/lib/",
 		"/usr/share/"
 	]
 }

src/config.cpp

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: MIT
  */
 
-#include <cassert>    // assert
 #include <csignal>    // raise
 #include <cstdio>     // fprintf
 #include <filesystem> // current_path, recursive_directory
@@ -13,7 +12,8 @@
 #include <vector>
 
 #include "config.h"
-#include "util/json/value.h"
+#include "ruc/json/json.h"
+#include "ruc/meta/assert.h"
 
 Config::Config(s)
 	: m_workingDirectory(std::filesystem::current_path())
@@ -51,7 +51,7 @@ void Config::parseConfigFile()
 		return;
 	}
 
-	Json::Value json;
+	ruc::Json json;
 
 	std::ifstream file(m_config);
 	if (!file.is_open()) {
@@ -72,17 +72,17 @@ void Config::parseConfigFile()
 
 // -----------------------------------------
 
-void toJson(Json::Value& json, const Settings& settings)
+void toJson(ruc::Json& json, const Settings& settings)
 {
-	json = Json::Value {
+	json = ruc::Json {
 		{ "ignorePatterns", settings.ignorePatterns },
 		{ "systemPatterns", settings.systemPatterns }
 	};
 }
 
-void fromJson(const Json::Value& json, Settings& settings)
+void fromJson(const ruc::Json& json, Settings& settings)
 {
-	assert(json.type() == Json::Value::Type::Object);
+	VERIFY(json.type() == ruc::Json::Type::Object);
 
 	if (json.exists("ignorePatterns")) {
 		json.at("ignorePatterns").getTo(settings.ignorePatterns);

src/config.h

@@ -4,16 +4,15 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef CONFIG_H
+#pragma once
-#define CONFIG_H
 
 #include <cstddef>    // size_t
 #include <filesystem> // path
 #include <string>
 #include <vector>
 
-#include "util/singleton.h"
+#include "ruc/json/json.h"
-#include "util/json/value.h"
+#include "ruc/singleton.h"
 
 struct Settings {
 	std::vector<std::string> ignorePatterns {
@@ -27,11 +26,12 @@ struct Settings {
 	std::vector<std::string> systemPatterns {
 		"/boot/",
 		"/etc/",
+		"/usr/lib/",
 		"/usr/share/"
 	};
 };
 
-class Config : public Util::Singleton<Config> {
+class Config : public ruc::Singleton<Config> {
 public:
 	Config(s);
 	virtual ~Config();
@@ -65,7 +65,5 @@ private:
 
 // Json arbitrary type conversion functions
 
-void toJson(Json::Value& object, const Settings& settings);
+void toJson(ruc::Json& object, const Settings& settings);
-void fromJson(const Json::Value& object, Settings& settings);
+void fromJson(const ruc::Json& object, Settings& settings);
-
-#endif // CONFIG_H

src/dotfile.cpp

@@ -1,10 +1,9 @@
 /*
- * Copyright (C) 2021-2022 Riyyi
+ * Copyright (C) 2021-2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <cassert> // assert
 #include <cctype>  // tolower
 #include <cstddef> // size_t
 #include <cstdio>  // fprintf, printf, stderr
@@ -16,10 +15,12 @@
 #include <unistd.h>     // geteuid, getlogin, setegid, seteuid
 #include <vector>
 
+#include "ruc/file.h"
+#include "ruc/meta/assert.h"
+
 #include "config.h"
 #include "dotfile.h"
 #include "machine.h"
-#include "util/file.h"
 
 Dotfile::Dotfile(s)
 {
@@ -107,14 +108,19 @@ void Dotfile::push(const std::vector<std::string>& targets)
 
 bool Dotfile::match(const std::string& path, const std::vector<std::string>& patterns)
 {
-	assert(path.front() == '/');
+	VERIFY(path.front() == '/', "path is not absolute: '{}'", path);
 
 	// Cut off working directory
 	size_t cutFrom = path.find(Config::the().workingDirectory()) == 0 ? Config::the().workingDirectorySize() : 0;
 	std::string pathString = path.substr(cutFrom);
 
 	for (const auto& pattern : patterns) {
+		// A dot matches everything in the current working directory
+		if (pattern == ".") {
+			return true;
+		}
 
+		// Exact match is obviously true
 		if (pathString == pattern) {
 			return true;
 		}
@@ -373,41 +379,60 @@ void Dotfile::sync(SyncType type,
 
 void Dotfile::selectivelyCommentOrUncomment(const std::string& path)
 {
-	Util::File dotfile(path);
+	ruc::File dotfile(path);
 
-	const std::string search[3] = {
+	const std::string search[4] = {
 		"distro=",
 		"hostname=",
 		"user=",
+		"session=",
 	};
 
 	// State of the loop
 	bool isFiltering = false;
-	std::string filter[3];
+	std::string filter[4];
 	std::string commentCharacter;
 	std::string commentTerminationCharacter;
 	size_t positionInFile = 0;
 
 	auto commentOrUncommentLine = [&](std::string& line, bool addComment) {
+		size_t indentation = line.find_first_not_of(" \t");
+
+		// Empty lines are skipped
+		if (line.empty() || indentation == std::string::npos) {
+			return;
+		}
+
 		size_t lineLength = line.size();
-		size_t whiteSpaceBeforeComment = line.find_first_not_of(" \t");
+		size_t commentStart = line.find(commentCharacter, indentation);
-		size_t contentAfterComment = line.find_first_not_of(" \t" + commentCharacter);
+		size_t commentEnd = line.rfind(commentTerminationCharacter);
-		// NOTE: The +1 is needed to take the newline into account
+		bool hasComment = commentStart != std::string::npos && (commentTerminationCharacter.empty() || commentEnd != std::string::npos);
-		size_t contentLength = lineLength + 1 - contentAfterComment - (lineLength - line.find_last_not_of(" \t" + commentTerminationCharacter));
 
-		// If there was no comment, grab whitespace correctly
+		// Lines that have a comment at the *end* of the line aren't considered commented lines
-		if (whiteSpaceBeforeComment == std::string::npos) {
+		if (hasComment && line.find_first_not_of(" \t") < commentStart) {
-			whiteSpaceBeforeComment = contentAfterComment;
+			hasComment = false;
 		}
 
-		if (!addComment) {
+		// Uncomment line
-			line = line.substr(0, whiteSpaceBeforeComment)
+		if (hasComment && !addComment) {
-			       + line.substr(contentAfterComment, contentLength);
+			size_t contentStart = line.find_first_not_of(" \t", commentStart + commentCharacter.size());
+			size_t contentLength = commentEnd - contentStart;
+
+			// Trim trailing whitespace
+			std::string content = line.substr(contentStart, contentLength);
+			content = content.substr(0, content.find_last_not_of(" \t") + 1);
+
+			line = line.substr(0, indentation)
+			       + content;
 		}
-		else {
+		// Comment line
-			line = line.substr(0, whiteSpaceBeforeComment)
+		else if (!hasComment && addComment) {
+			size_t contentStart = line.find_first_not_of(" \t");
+			size_t contentLength = line.size() - contentStart;
+
+			line = line.substr(0, indentation)
 			       + commentCharacter + ' '
-			       + line.substr(contentAfterComment, contentLength)
+			       + line.substr(contentStart, contentLength)
 			       + (!commentTerminationCharacter.empty() ? ' ' + commentTerminationCharacter : "");
 		}
 
@@ -420,7 +445,7 @@ void Dotfile::selectivelyCommentOrUncomment(const std::string& path)
 		if (line.find(">>>") != std::string::npos) {
 			// Find machine info
 			size_t find = 0;
-			for (size_t i = 0; i < 3; ++i) {
+			for (size_t i = 0; i < 4; ++i) {
 				find = line.find(search[i]) + search[i].size();
 				if (find < search[i].size()) {
 					continue;
@@ -435,6 +460,10 @@ void Dotfile::selectivelyCommentOrUncomment(const std::string& path)
 				if (i > 0 && commentCharacter.at(i - 1) == '/' && commentCharacter.at(i) == '*') {
 					commentTerminationCharacter = "*/";
 				}
+				// Support for <!-- XMl comments -->
+				if (i > 0 && commentCharacter.at(i - 1) == '<' && commentCharacter.at(i) == '!' && commentCharacter.at(i + 1) == '-' && commentCharacter.at(i + 2) == '-') {
+					commentTerminationCharacter = "-->";
+				}
 				// NOTE: Modification of the string should be at the end of the iteration to prevent 'out of range' errors
 				if (commentCharacter.at(i) == ' ' || commentCharacter.at(i) == '\t') {
 					commentCharacter.erase(i, 1);
@@ -450,6 +479,7 @@ void Dotfile::selectivelyCommentOrUncomment(const std::string& path)
 			filter[0] = "";
 			filter[1] = "";
 			filter[2] = "";
+			filter[3] = "";
 			commentCharacter.clear();
 			commentTerminationCharacter.clear();
 			continue;
@@ -471,6 +501,10 @@ void Dotfile::selectivelyCommentOrUncomment(const std::string& path)
 			commentOrUncommentLine(line, true);
 			continue;
 		}
+		else if (filter[3] != Machine::the().session() && !filter[3].empty()) {
+			commentOrUncommentLine(line, true);
+			continue;
+		}
 
 		commentOrUncommentLine(line, false);
 	}

src/dotfile.h

@@ -4,23 +4,23 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef DOTFILE_H
+#pragma once
-#define DOTFILE_H
 
 #include <cstddef> // size_t
+#include <cstdint> // uint8_t
 #include <filesystem>
 #include <functional> // function
 #include <string>
 #include <vector>
 
-#include "util/singleton.h"
+#include "ruc/singleton.h"
 
-class Dotfile : public Util::Singleton<Dotfile> {
+class Dotfile : public ruc::Singleton<Dotfile> {
 public:
 	Dotfile(s);
 	virtual ~Dotfile();
 
-	enum class SyncType {
+	enum class SyncType : uint8_t {
 		Add,
 		Pull,
 		Push,
@@ -43,5 +43,3 @@ private:
 
 	void forEachDotfile(const std::vector<std::string>& targets, const std::function<void(const std::filesystem::directory_entry&, size_t)>& callback);
 };
-
-#endif // DOTFILE_H

src/machine.cpp

@@ -1,21 +1,25 @@
 /*
- * Copyright (C) 2022 Riyyi
+ * Copyright (C) 2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#include <pwd.h>    // getpwnam
+#include <cstdint>    // int8_t
-#include <sstream>  // istringstream
+#include <filesystem> // std::filesystem::path
-#include <unistd.h> // gethostname, getlogin
+#include <pwd.h>      // getpwnam
+#include <sstream>    // istringstream
+#include <unistd.h>   // gethostname, getlogin
+
+#include "ruc/file.h"
 
 #include "machine.h"
-#include "util/file.h"
 
 Machine::Machine(s)
 {
 	fetchDistro();
 	fetchHostname();
 	fetchUsername();
+	fetchSession();
 }
 
 Machine::~Machine()
@@ -26,7 +30,7 @@ Machine::~Machine()
 
 void Machine::fetchDistro()
 {
-	Util::File osRelease("/etc/os-release");
+	ruc::File osRelease("/etc/os-release");
 	std::istringstream stream(osRelease.data());
 	for (std::string line; std::getline(stream, line);) {
 		if (line.find("ID=") == 0) {
@@ -61,3 +65,83 @@ void Machine::fetchUsername()
 		perror("\033[31;1mError:\033[0m getpwnam");
 	}
 }
+
+void Machine::fetchSession()
+{
+	// Determine if this is an Xorg or Wayland session
+	int8_t likelyWayland = 0;
+
+	// Detect via environment variable
+	const char* env;
+	env = std::getenv("XDG_SESSION_TYPE");
+	if (env != nullptr) {
+		auto session = std::string(env);
+		if (session == "wayland") {
+			likelyWayland++;
+		}
+		else if (session == "x11") {
+			likelyWayland--;
+		}
+	}
+	env = std::getenv("WAYLAND_DISPLAY");
+	if (env != nullptr) {
+		auto display = std::string(env);
+		if (display.find("wayland-", 0) == 0) {
+			likelyWayland++;
+		}
+	}
+
+	// Detect via Wayland socket
+	auto socket = std::filesystem::path("/run/user") / std::to_string(uid());
+	if (std::filesystem::exists(socket) && std::filesystem::is_directory(socket)) {
+		for (const auto& entry : std::filesystem::directory_iterator(socket)) {
+			if (entry.path().filename().string().find("wayland-", 0) == 0) {
+				likelyWayland++;
+				break;
+			}
+		}
+	}
+
+	// Detect via Xorg socket
+	if (std::filesystem::exists("/tmp/.X11-unix")) {
+		likelyWayland--;
+	}
+
+	// Detect via running processes, /proc/<id>/comm
+	std::filesystem::path processes = "/proc";
+	if (std::filesystem::exists(processes) && std::filesystem::is_directory(processes)) {
+		for (const auto& entry : std::filesystem::directory_iterator(processes)) {
+			if (std::filesystem::is_directory(entry)) {
+
+				std::filesystem::path comm = entry.path() / "comm";
+				if (!std::filesystem::exists(comm)) {
+					continue;
+				}
+
+				// Read the contents of the "comm" file
+				std::ifstream stream(comm);
+				std::string command;
+				std::getline(stream, command);
+
+				if (command == "Xwayland" || command == "sway" || command == "hyprland") {
+					likelyWayland++;
+					break;
+				}
+
+				if (command == "Xorg" || command == "xinit" || command == "i3" || command == "bspwm") {
+					likelyWayland--;
+					break;
+				}
+			}
+		}
+	}
+
+	// If we detected at least 2 ways, we can be fairly certain
+	m_session = "";
+	if (likelyWayland <= -2) {
+		m_session = "xorg";
+	}
+	else if (likelyWayland >= 2) {
+		m_session = "wayland";
+	}
+}

src/machine.h

@@ -4,37 +4,38 @@
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef MACHINE_H
+#pragma once
-#define MACHINE_H
 
 #include <cstdint> // uint32_t
 #include <pwd.h>   // passwd
 #include <string>
 
-#include "util/singleton.h"
+#include "ruc/singleton.h"
 
-class Machine : public Util::Singleton<Machine> {
+class Machine : public ruc::Singleton<Machine> {
 public:
 	Machine(s);
 	virtual ~Machine();
 
-	const std::string& distroId() { return m_distroId; }
+	const std::string& distroId() const { return m_distroId; }
-	const std::string& distroIdLike() { return m_distroIdLike; }
+	const std::string& distroIdLike() const { return m_distroIdLike; }
-	const std::string& hostname() { return m_hostname; }
+	const std::string& hostname() const { return m_hostname; }
 
-	std::string username() { return m_passwd->pw_name; }
+	std::string username() const { return std::string(m_passwd->pw_name); }
-	uint32_t uid() { return m_passwd->pw_uid; }
+	uint32_t uid() const { return m_passwd->pw_uid; }
-	uint32_t gid() { return m_passwd->pw_gid; }
+	uint32_t gid() const { return m_passwd->pw_gid; }
+
+	const std::string& session() const { return m_session; }
 
 private:
 	void fetchDistro();
 	void fetchHostname();
 	void fetchUsername();
+	void fetchSession();
 
 	std::string m_distroId;
 	std::string m_distroIdLike;
 	std::string m_hostname;
+	std::string m_session;
 	passwd* m_passwd { nullptr };
 };
-
-#endif // MACHINE_H

src/main.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Riyyi
+ * Copyright (C) 2021-2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -8,11 +8,12 @@
 #include <string>
 #include <vector>
 
+#include "ruc/argparser.h"
+#include "ruc/timer.h"
+
 #include "config.h"
 #include "dotfile.h"
 #include "package.h"
-#include "util/argparser.h"
-#include "util/timer.h"
 
 int main(int argc, const char* argv[])
 {
@@ -23,12 +24,12 @@ int main(int argc, const char* argv[])
 	bool addOrAur = false;
 	bool install = false;
 	bool pull = false;
-	bool pushOrStore = false;
+	bool pushOrSearch = false;
 	bool verbose = false;
 
 	std::vector<std::string> targets {};
 
-	Util::ArgParser argParser;
+	ruc::ArgParser argParser;
 	argParser.addOption(fileOperation, 'F', "file", nullptr, nullptr);
 	argParser.addOption(packageOperation, 'P', "package", nullptr, nullptr);
 	argParser.addOption(helpOperation, 'h', "help", nullptr, nullptr);
@@ -36,10 +37,10 @@ int main(int argc, const char* argv[])
 	argParser.addOption(addOrAur, 'a', "add", nullptr, nullptr);
 	argParser.addOption(install, 'i', "install", nullptr, nullptr);
 	argParser.addOption(pull, 'l', "pull", nullptr, nullptr);
-	argParser.addOption(pushOrStore, 's', "push", nullptr, nullptr);
+	argParser.addOption(pushOrSearch, 's', "push", nullptr, nullptr);
 	argParser.addOption(verbose, 'v', "verbose", nullptr, nullptr);
 
-	argParser.addArgument(targets, "targets", nullptr, nullptr, Util::ArgParser::Required::No);
+	argParser.addArgument(targets, "targets", nullptr, nullptr, ruc::ArgParser::Required::No);
 	argParser.parse(argc, argv);
 
 	if (fileOperation + packageOperation + helpOperation > 1) {
@@ -48,7 +49,7 @@ int main(int argc, const char* argv[])
 	}
 
 #ifndef NDEBUG
-	Util::Timer t;
+	ruc::Timer t;
 #endif
 
 	Config::the().setVerbose(verbose);
@@ -60,36 +61,33 @@ int main(int argc, const char* argv[])
 		if (pull) {
 			Dotfile::the().pull(targets);
 		}
-		if (pushOrStore) {
+		if (pushOrSearch) {
 			Dotfile::the().push(targets);
 		}
-		if (!addOrAur && !pull && !pushOrStore) {
+		if (!addOrAur && !pull && !pushOrSearch) {
 			Dotfile::the().list(targets);
 		}
 	}
 	else if (packageOperation) {
 		if (addOrAur) {
-			Package::the().aurInstall();
+			Package::the().aurInstall(targets);
 		}
 		if (install) {
-			Package::the().install();
+			Package::the().install(targets);
 		}
-		if (pushOrStore) {
+		if (!addOrAur && !install) {
-			Package::the().store();
+			Package::the().list(targets, pushOrSearch);
-		}
-		if (!addOrAur && !install && !pushOrStore) {
-			Package::the().list(targets);
 		}
 	}
 	else if (helpOperation) {
-		// TODO open manpage
+		// TODO: open manpage
 	}
 	else {
-		// TODO open manpage
+		// TODO: open manpage
 	}
 
 #ifndef NDEBUG
-		printf("%fms\n", t.elapsedNanoseconds() / 1000000.0);
+	printf("%fms\n", t.elapsedNanoseconds() / 1000000.0);
 #endif
 
 	return 0;

src/package.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Riyyi
+ * Copyright (C) 2021-2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
@@ -14,11 +14,11 @@
 #include <string>  // getline
 #include <vector>
 
+#include "ruc/shell.h"
+#include "ruc/system.h"
+
 #include "machine.h"
 #include "package.h"
-#include "util/file.h"
-#include "util/shell.h"
-#include "util/system.h"
 
 Package::Package(s)
 {
@@ -30,17 +30,27 @@ Package::~Package()
 
 // -----------------------------------------
 
-void Package::aurInstall()
+void Package::aurInstall(const std::vector<std::string>& targets)
 {
-	installOrAurInstall(InstallType::AurInstall);
+	if (targets.size() > 1) {
+		fprintf(stderr, "\033[31;1mPackage:\033[0m only 1 file can be read packages from at a time\n");
+		return;
+	}
+
+	installOrAurInstall(InstallType::AurInstall, targets.size() != 0 ? targets.front() : PACKAGE_FILE);
 }
 
-void Package::install()
+void Package::install(const std::vector<std::string>& targets)
 {
-	installOrAurInstall(InstallType::Install);
+	if (targets.size() > 1) {
+		fprintf(stderr, "\033[31;1mPackage:\033[0m only 1 file can be read packages from at a time\n");
+		return;
+	}
+
+	installOrAurInstall(InstallType::Install, targets.size() != 0 ? targets.front() : PACKAGE_FILE);
 }
 
-void Package::list(const std::vector<std::string>& targets)
+void Package::list(const std::vector<std::string>& targets, bool partialMatch)
 {
 	auto packagesOrEmpty = getPackageList();
 
@@ -62,7 +72,7 @@ void Package::list(const std::vector<std::string>& targets)
 	std::string line;
 	while (std::getline(stream, line)) {
 		for (const auto& target : targets) {
-			if (line.find(target) != std::string::npos) {
+			if (line == target || (partialMatch && line.find(target) != std::string::npos)) {
 				packages.append(line + '\n');
 				break;
 			}
@@ -72,20 +82,6 @@ void Package::list(const std::vector<std::string>& targets)
 	printf("%s", packages.c_str());
 }
 
-void Package::store()
-{
-	auto packagesOrEmpty = getPackageList();
-
-	if (!packagesOrEmpty.has_value()) {
-		return;
-	}
-
-	auto packageFile = Util::File::create("./packages");
-	packageFile.clear();
-	packageFile.append(packagesOrEmpty.value());
-	packageFile.flush();
-}
-
 // -----------------------------------------
 
 std::optional<std::string> Package::fetchAurHelper()
@@ -105,7 +101,7 @@ std::optional<std::string> Package::fetchAurHelper()
 	return {};
 }
 
-void Package::installOrAurInstall(InstallType type)
+void Package::installOrAurInstall(InstallType type, const std::string& file)
 {
 	distroDetect();
 	distroDependencies();
@@ -126,15 +122,15 @@ void Package::installOrAurInstall(InstallType type)
 
 	std::string command = "";
 
-	Util::System $;
+	ruc::System $;
 	if (m_distro == Distro::Arch) {
 		// Grab everything off enabled official repositories that is in the list
-		auto repoList = $("pacman -Ssq") | $("grep -xf ./packages");
+		auto repoList = $("pacman -Ssq") | $("grep -xf " + file);
 
 		if (type == InstallType::AurInstall) {
 			// Determine which packages in the list are from the AUR
-			// NOTE: Util::System does not support commands with newlines
+			// NOTE: ruc::System does not support commands with newlines
-			auto aurList = Util::Shell()("grep -vx '" + repoList.output() + "' ./packages");
+			auto aurList = ruc::Shell()("grep -vx '" + repoList.output() + "' " + file);
 			command = aurHelper.value() + " -Sy --devel --needed --noconfirm " + aurList.output();
 		}
 		else {
@@ -143,7 +139,7 @@ void Package::installOrAurInstall(InstallType type)
 	}
 	else if (m_distro == Distro::Debian) {
 		// Grab everything off enabled official repositories that is in the list
-		auto repoList = $("apt-cache search .").cut(1, ' ') | $("grep -xf ./packages");
+		auto repoList = $("apt-cache search .").cut(1, ' ') | $("grep -xf " + file);
 		command = "apt install " + repoList.output();
 	}
 
@@ -224,7 +220,7 @@ std::optional<std::string> Package::getPackageList()
 
 	std::string packages;
 
-	Util::System $;
+	ruc::System $;
 	if (m_distro == Distro::Arch) {
 		auto basePackages = $("pactree -u base").tail(2, true);
 		auto develPackages = $("pacman -Qqg base-devel");

src/package.h

@@ -1,42 +1,43 @@
 /*
- * Copyright (C) 2021-2022 Riyyi
+ * Copyright (C) 2021-2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
-#ifndef PACKAGE_H
+#pragma once
-#define PACKAGE_H
 
+#include <cstdint> // uint8_t
 #include <optional>
 #include <string>
 #include <vector>
 
-#include "util/singleton.h"
+#include "ruc/singleton.h"
 
-class Package : public Util::Singleton<Package> {
+#define PACKAGE_FILE "./packages"
+
+class Package : public ruc::Singleton<Package> {
 public:
 	Package(s);
 	virtual ~Package();
 
-	enum class Distro {
+	enum class Distro : uint8_t {
 		Unsupported,
 		Arch,
 		Debian,
 	};
 
-	enum class InstallType {
+	enum class InstallType : uint8_t {
 		Install,
 		AurInstall,
 	};
 
-	void aurInstall();
+	void aurInstall(const std::vector<std::string>& targets = {});
-	void install();
+	void install(const std::vector<std::string>& targets = {});
-	void list(const std::vector<std::string>& targets = {});
+	void list(const std::vector<std::string>& targets = {}, bool partialMatch = false);
-	void store();
 
 private:
 	std::optional<std::string> fetchAurHelper();
-	void installOrAurInstall(InstallType type);
+	void installOrAurInstall(InstallType type, const std::string& file);
 
 	bool findDependency(const std::string& search);
 	bool distroDetect();
@@ -45,5 +46,3 @@ private:
 
 	Distro m_distro { Distro::Unsupported };
 };
-
-#endif // PACKAGE_H

src/util/argparser.cpp

@@ -1,567 +0,0 @@
-/*
- * Copyright (C) 2021-2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <algorithm> // find_if
-#include <cstddef>   // size_t
-#include <cstdio>    // printf
-#include <cstring>   // strcmp
-#include <limits>    // numeric_limits
-#include <string>    // stod, stoi, stoul
-#include <string_view>
-#include <vector>
-
-#include "util/argparser.h"
-
-namespace Util {
-
-ArgParser::ArgParser()
-{
-}
-
-ArgParser::~ArgParser()
-{
-}
-
-void ArgParser::printError(char parameter, Error error)
-{
-	char tmp[] { parameter, '\0' };
-	printError(tmp, error, false);
-}
-
-void ArgParser::printError(const char* parameter, Error error, bool longName)
-{
-	if (!m_errorReporting) {
-		return;
-	}
-
-	if (error == Error::OptionInvalid) {
-		printf("%s: invalid option -- '%s'\n", m_name, parameter);
-	}
-	else if (error == Error::OptionUnrecognized) {
-		printf("%s: unrecognized option -- '%s'\n", m_name, parameter);
-	}
-	else if (error == Error::OptionDoesntAllowArgument) {
-		printf("%s: option '--%s' doesn't allow an argument\n", m_name, parameter);
-	}
-	else if (error == Error::OptionRequiresArgument) {
-		if (longName) {
-			printf("%s: option '--%s' requires an argument\n", m_name, parameter);
-		}
-		else {
-			printf("%s: option requires an argument -- '%s'\n", m_name, parameter);
-		}
-	}
-	else if (error == Error::OptionInvalidArgumentType) {
-		if (longName) {
-			printf("%s: option '--%s' invalid type\n", m_name, parameter);
-		}
-		else {
-			printf("%s: option invalid type -- '%s'\n", m_name, parameter);
-		}
-	}
-	else if (error == Error::ArgumentExtraOperand) {
-		printf("%s: extra operand '%s'\n", m_name, parameter);
-	}
-	else if (error == Error::ArgumentRequired) {
-		printf("%s: missing required argument '%s'\n", m_name, parameter);
-	}
-	else if (error == Error::ArgumentInvalidType) {
-		printf("%s: invalid argument type '%s'\n", m_name, parameter);
-	}
-
-	// TODO: Print command usage, if it's enabled.
-}
-
-// Required: directly after || separated by space
-// Optional: directly after
-bool ArgParser::parseShortOption(std::string_view option, std::string_view next)
-{
-	bool result = true;
-
-#ifndef NDEBUG
-	printf("Parsing short option: '%s'\n", option.data());
-#endif
-
-	char c;
-	std::string_view value;
-	for (size_t i = 0; i < option.size(); ++i) {
-		c = option.at(i);
-
-#ifndef NDEBUG
-		printf("short '%c'\n", c);
-#endif
-
-		auto foundOption = std::find_if(m_options.begin(), m_options.end(), [&c](Option& it) -> bool {
-			return it.shortName == c;
-		});
-
-		// Option does not exist
-		if (foundOption == m_options.cend()) {
-			printError(c, Error::OptionInvalid);
-
-			if (m_exitOnFirstError) {
-				return false;
-			}
-		}
-		else if (foundOption->requiresArgument == Required::No) {
-			// FIXME: Figure out why providing a nullptr breaks the lambda here.
-			result = foundOption->acceptValue("");
-		}
-		else if (foundOption->requiresArgument == Required::Yes) {
-			value = option.substr(i + 1);
-			if (value.empty() && next.empty()) {
-				foundOption->error = Error::OptionRequiresArgument;
-				printError(c, Error::OptionRequiresArgument);
-				result = false;
-			}
-			else if (!value.empty()) {
-				result = foundOption->acceptValue(value.data());
-				if (!result) {
-					printError(c, Error::OptionInvalidArgumentType);
-				}
-			}
-			else if (next[0] == '-') {
-				foundOption->error = Error::OptionRequiresArgument;
-				printError(c, Error::OptionRequiresArgument);
-				result = false;
-			}
-			else {
-				result = foundOption->acceptValue(next.data());
-				m_optionIndex++;
-				if (!result) {
-					printError(c, Error::OptionInvalidArgumentType);
-				}
-			}
-
-			break;
-		}
-		else if (foundOption->requiresArgument == Required::Optional) {
-			value = option.substr(i + 1);
-			if (!value.empty()) {
-				result = foundOption->acceptValue(value.data());
-				if (!result) {
-					printError(c, Error::OptionInvalidArgumentType);
-				}
-				break;
-			}
-		}
-	}
-
-	return result;
-}
-
-// Required: directly after, separated by '=' || separated by space
-// Optional: directly after, separated by '='
-bool ArgParser::parseLongOption(std::string_view option, std::string_view next)
-{
-	std::string name = std::string(option.substr(0, option.find_first_of('=')));
-	std::string_view value = option.substr(option.find_first_of('=') + 1);
-
-	auto foundOption = std::find_if(m_options.begin(), m_options.end(), [&name](Option& it) -> bool {
-		return it.longName && it.longName == name;
-	});
-
-	if (foundOption == m_options.cend()) {
-		printError(name.data(), Error::OptionUnrecognized);
-		return false;
-	}
-
-	enum class ArgumentProvided {
-		No,
-		DirectlyAfter,
-		Seperated,
-	};
-
-	auto argument = ArgumentProvided::No;
-	if (name != value || option.find('=') != std::string_view::npos) {
-		argument = ArgumentProvided::DirectlyAfter;
-	}
-	else if (!next.empty() && next[0] != '-') {
-		argument = ArgumentProvided::Seperated;
-		value = next;
-	}
-
-	bool result = true;
-
-	if (foundOption->requiresArgument == Required::No) {
-		if (argument == ArgumentProvided::DirectlyAfter) {
-			foundOption->error = Error::OptionDoesntAllowArgument;
-			printError(name.data(), Error::OptionDoesntAllowArgument);
-			return false;
-		}
-
-		result = foundOption->acceptValue("");
-	}
-	else if (foundOption->requiresArgument == Required::Yes) {
-		if (argument == ArgumentProvided::No) {
-			foundOption->error = Error::OptionRequiresArgument;
-			printError(name.data(), Error::OptionRequiresArgument);
-			return false;
-		}
-
-		result = foundOption->acceptValue(value.data());
-		if (!result) {
-			printError(name.data(), Error::OptionInvalidArgumentType);
-		}
-
-		if (argument == ArgumentProvided::Seperated) {
-			m_optionIndex++;
-		}
-	}
-	else if (foundOption->requiresArgument == Required::Optional) {
-		if (argument == ArgumentProvided::DirectlyAfter) {
-			result = foundOption->acceptValue(value.data());
-			if (!result) {
-				printError(name.data(), Error::OptionInvalidArgumentType);
-			}
-		}
-	}
-
-	return result;
-}
-
-bool ArgParser::parseArgument(std::string_view argument)
-{
-	bool result = true;
-
-	for (;;) {
-		// Run out of argument handlers
-		if (m_argumentIndex >= m_arguments.size()) {
-			printError(argument.data(), Error::ArgumentExtraOperand);
-			return false;
-		}
-
-		Argument& currentArgument = m_arguments.at(m_argumentIndex);
-		result = currentArgument.acceptValue(argument.data());
-
-		if (result) {
-			currentArgument.addedValues++;
-			if (currentArgument.addedValues >= currentArgument.maxValues) {
-				m_argumentIndex++;
-			}
-		}
-		else if (currentArgument.minValues == 0) {
-			m_argumentIndex++;
-			continue;
-		}
-		else {
-			printError(argument.data(), Error::ArgumentInvalidType);
-		}
-
-		break;
-	}
-
-	return result;
-}
-
-bool ArgParser::parse(int argc, const char* argv[])
-{
-	bool result = true;
-
-	// Set looping indices
-	m_optionIndex = 1;
-	m_argumentIndex = 0;
-
-	// By default parse all '-' prefixed parameters as options
-	m_nonOptionMode = false;
-
-	// Get program name
-	m_name = argv[0] + std::string_view(argv[0]).find_last_of('/') + 1;
-
-	std::string_view argument;
-	std::string_view next;
-	for (; m_optionIndex < (size_t)argc; ++m_optionIndex) {
-
-#ifndef NDEBUG
-		printf("argv[%zu]: %s\n", m_optionIndex, argv[m_optionIndex]);
-#endif
-
-		// Get the current and next parameter
-		argument = argv[m_optionIndex];
-		if (m_optionIndex + 1 < (size_t)argc && argv[m_optionIndex + 1][0] != '-') {
-			next = argv[m_optionIndex + 1];
-		}
-		else {
-			next = {};
-		}
-
-		// Stop parsing '-' prefixed parameters as options afer '--'
-		if (argument.compare("--") == 0) {
-			m_nonOptionMode = true;
-			continue;
-		}
-
-		// Long Option
-		if (!m_nonOptionMode && argument[0] == '-' && argument[1] == '-') {
-			argument = argument.substr(argument.find_first_not_of('-'));
-			if (!parseLongOption(argument, next)) {
-				result = false;
-			}
-		}
-		// Short Option
-		else if (!m_nonOptionMode && argument[0] == '-') {
-			argument = argument.substr(argument.find_first_not_of('-'));
-			if (!parseShortOption(argument, next)) {
-				result = false;
-			}
-		}
-		// Argument
-		else {
-			if (m_stopParsingOnFirstNonOption) {
-				m_nonOptionMode = true;
-			}
-			if (!parseArgument(argument)) {
-				result = false;
-			}
-		}
-
-		if (m_exitOnFirstError && !result) {
-			break;
-		}
-	}
-
-	// Check any leftover arguments for required
-	for (; m_argumentIndex < m_arguments.size(); ++m_argumentIndex) {
-		Argument& currentArgument = m_arguments.at(m_argumentIndex);
-		if (currentArgument.minValues > currentArgument.addedValues) {
-			result = false;
-			printError(currentArgument.name ? currentArgument.name : "", Error::ArgumentRequired);
-		}
-	}
-
-	if (result) {
-		return true;
-	}
-
-	for (auto& option : m_options) {
-		if (option.longName && strcmp(option.longName, "help") == 0) {
-			printf("Try '%s --help' for more information.\n", m_name);
-			break;
-		}
-		if (option.shortName == 'h') {
-			printf("Try '%s -h' for more information.\n", m_name);
-			break;
-		}
-	}
-
-	return false;
-}
-
-// -----------------------------------------
-
-void ArgParser::addOption(Option&& option)
-{
-	m_options.push_back(option);
-}
-
-void ArgParser::addOption(bool& value, char shortName, const char* longName, const char* usageString, const char* manString)
-{
-	addOption({ shortName, longName, nullptr, usageString, manString, Required::No, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(const char*& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(std::string& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(std::string_view& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(int& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(unsigned int& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(double& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(value) });
-}
-
-void ArgParser::addOption(std::vector<std::string>& values, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName, Required requiresArgument)
-{
-	addOption({ shortName, longName, argumentName, usageString, manString, requiresArgument, getAcceptFunction(values) });
-}
-
-// -----------------------------------------
-
-void ArgParser::addArgument(Argument&& argument)
-{
-	m_arguments.push_back(argument);
-}
-
-void ArgParser::addArgument(bool& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(const char*& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(std::string& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(std::string_view& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(int& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(unsigned int& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(double& value, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, 1, 0, getAcceptFunction(value) });
-}
-
-void ArgParser::addArgument(std::vector<std::string>& values, const char* name, const char* usageString, const char* manString, Required required)
-{
-	size_t minValues = required == Required::Yes ? 1 : 0;
-	addArgument({ name, usageString, manString, minValues, values.max_size(), 0, getAcceptFunction(values) });
-}
-
-// -----------------------------------------
-
-AcceptFunction ArgParser::getAcceptFunction(bool& value)
-{
-	return [&value](const char*) -> bool {
-		value = true;
-		return true;
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(const char*& value)
-{
-	return [&value](const char* input) -> bool {
-		value = input;
-		return true;
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(std::string& value)
-{
-	return [&value](const char* input) -> bool {
-		value = input;
-		return true;
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(std::string_view& value)
-{
-	return [&value](const char* input) -> bool {
-		value = input;
-		return true;
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(int& value)
-{
-	return [&value](const char* input) -> bool {
-		const char* validate = input;
-		for (; *validate != '\0'; ++validate) {
-			// - [0-9]
-			if (*validate != 45 && (*validate < 48 || *validate > 57)) {
-				return false;
-			}
-		}
-
-		try {
-			value = std::stoi(input);
-			return true;
-		}
-		catch (...) {
-			return false;
-		}
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(unsigned int& value)
-{
-	return [&value](const char* input) -> bool {
-		const char* validate = input;
-		for (; *validate != '\0'; ++validate) {
-			// [0-9]
-			if (*validate < 48 || *validate > 57) {
-				return false;
-			}
-		}
-
-		unsigned long convert = 0;
-		try {
-			convert = std::stoul(input);
-		}
-		catch (...) {
-			return false;
-		}
-
-		if (convert <= std::numeric_limits<unsigned int>::max()) {
-			value = static_cast<unsigned int>(convert);
-			return true;
-		}
-
-		return false;
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(double& value)
-{
-	return [&value](const char* input) -> bool {
-		const char* validate = input;
-		for (; *validate != '\0'; ++validate) {
-			// . [0-9]
-			if (*validate != 46 && (*validate < 48 || *validate > 57)) {
-				return false;
-			}
-		}
-
-		try {
-			value = std::stod(input);
-			return true;
-		}
-		catch (...) {
-			return false;
-		}
-	};
-}
-
-AcceptFunction ArgParser::getAcceptFunction(std::vector<std::string>& value)
-{
-	return [&value](const char* input) -> bool {
-		value.push_back(input);
-		return true;
-	};
-}
-
-} // namespace Util

src/util/argparser.h

@@ -1,116 +0,0 @@
-#ifndef ARG_PARSER_H
-#define ARG_PARSER_H
-
-#include <cstddef>    // size_t
-#include <functional> // function
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace Util {
-
-using AcceptFunction = std::function<bool(const char*)>;
-
-class ArgParser final {
-public:
-	ArgParser();
-	virtual ~ArgParser();
-
-	enum class Required {
-		No,
-		Yes,
-		Optional,
-	};
-
-	enum class Error {
-		None,
-		OptionInvalid,      // For short options
-		OptionUnrecognized, // For long options
-		OptionDoesntAllowArgument,
-		OptionRequiresArgument,
-		OptionInvalidArgumentType,
-		ArgumentExtraOperand,
-		ArgumentRequired,
-		ArgumentInvalidType,
-	};
-
-	struct Option {
-		char shortName { 0 };
-		const char* longName { nullptr };
-		const char* argumentName { nullptr };
-		const char* usageString { nullptr };
-		const char* manString { nullptr };
-		Required requiresArgument;
-		AcceptFunction acceptValue;
-
-		Error error = Error::None;
-	};
-
-	struct Argument {
-		const char* name { nullptr };
-		const char* usageString { nullptr };
-		const char* manString { nullptr };
-		size_t minValues { 0 };
-		size_t maxValues { 1 };
-		size_t addedValues { 0 };
-		AcceptFunction acceptValue;
-	};
-
-	bool parse(int argc, const char* argv[]);
-
-	void addOption(Option&& option);
-	void addOption(bool& value, char shortName, const char* longName, const char* usageString, const char* manString);
-	void addOption(const char*& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(std::string& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(std::string_view& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(int& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(unsigned int& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(double& value, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-	void addOption(std::vector<std::string>& values, char shortName, const char* longName, const char* usageString, const char* manString, const char* argumentName = "", Required requiresArgument = Required::No);
-
-	void addArgument(Argument&& argument);
-	void addArgument(bool& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(const char*& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(std::string& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(std::string_view& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(int& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(unsigned int& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(double& value, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-	void addArgument(std::vector<std::string>& values, const char* name, const char* usageString, const char* manString, Required required = Required::No);
-
-	void setErrorReporting(bool state) { m_errorReporting = state; }
-	void setExitOnFirstError(bool state) { m_exitOnFirstError = state; }
-	void setStopParsingOnFirstNonOption(bool state) { m_stopParsingOnFirstNonOption = state; }
-
-private:
-	void printError(char parameter, Error error);
-	void printError(const char* parameter, Error error, bool longName = true);
-	bool parseShortOption(std::string_view option, std::string_view next);
-	bool parseLongOption(std::string_view option, std::string_view next);
-	bool parseArgument(std::string_view argument);
-
-	AcceptFunction getAcceptFunction(bool& value);
-	AcceptFunction getAcceptFunction(const char*& value);
-	AcceptFunction getAcceptFunction(std::string& value);
-	AcceptFunction getAcceptFunction(std::string_view& value);
-	AcceptFunction getAcceptFunction(int& value);
-	AcceptFunction getAcceptFunction(unsigned int& value);
-	AcceptFunction getAcceptFunction(double& value);
-	AcceptFunction getAcceptFunction(std::vector<std::string>& value);
-
-	bool m_errorReporting { true };
-	bool m_exitOnFirstError { true };
-	bool m_stopParsingOnFirstNonOption { false };
-
-	size_t m_optionIndex { 1 };
-	size_t m_argumentIndex { 0 };
-	bool m_nonOptionMode { false };
-
-	const char* m_name { nullptr };
-	std::vector<Option> m_options;
-	std::vector<Argument> m_arguments;
-};
-
-} // namespace Util
-
-#endif // ARG_PARSER_H

src/util/file.cpp

@@ -1,89 +0,0 @@
-/*
- * Copyright (C) 2021-2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <cassert> // assert
-#include <cstdint> // int32_t
-#include <filesystem>
-#include <fstream> // ifstream, ios, ofstream
-#include <memory>  // make_unique
-#include <string>
-
-#include "util/file.h"
-
-namespace Util {
-
-File::File(const std::string& path)
-	: m_path(path)
-{
-	// Create input stream object and open file
-	std::ifstream file(path, std::ios::in);
-	assert(file.is_open());
-
-	// Get length of the file
-	file.seekg(0, std::ios::end);
-	int32_t size = file.tellg();
-	file.seekg(0, std::ios::beg);
-	assert(size != -1);
-
-	// Allocate memory filled with zeros
-	auto buffer = std::make_unique<char[]>(size);
-
-	// Fill buffer with file contents
-	file.read(buffer.get(), size);
-	file.close();
-
-	m_data = std::string(buffer.get(), size);
-}
-
-File::~File()
-{
-}
-
-// -----------------------------------------
-
-File File::create(const std::string& path)
-{
-	if (!std::filesystem::exists(path)) {
-		std::ofstream { path };
-	}
-
-	return Util::File(path);
-}
-
-// -----------------------------------------
-
-void File::clear()
-{
-	m_data.clear();
-}
-
-File& File::append(const std::string& data)
-{
-	m_data.append(data);
-
-	return *this;
-}
-
-File& File::replace(size_t index, size_t length, const std::string& data)
-{
-	m_data.replace(index, length, data);
-
-	return *this;
-}
-
-File& File::flush()
-{
-	// Create output stream object and open file
-	std::ofstream file(m_path, std::ios::out | std::ios::trunc);
-	assert(file.is_open());
-
-	// Write data to disk
-	file.write(m_data.c_str(), m_data.size());
-
-	return *this;
-}
-
-} // namespace Util

src/util/file.h

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2021-2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef FILE_H
-#define FILE_H
-
-#include <string>
-
-namespace Util {
-
-class File {
-public:
-	File(const std::string& path);
-	virtual ~File();
-
-	static File create(const std::string& path);
-
-	void clear();
-	File& append(const std::string& data);
-	File& replace(size_t index, size_t length, const std::string& data);
-	File& flush();
-
-	const char* c_str() const { return m_data.c_str(); }
-	const std::string& data() const { return m_data; }
-	const std::string& path() const { return m_path; }
-
-private:
-	std::string m_path;
-	std::string m_data;
-};
-
-} // namespace Util
-
-
-#endif // FILE_H

src/util/json/array.cpp

@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "util/json/array.h"
-#include "util/json/value.h"
-
-namespace Json {
-
-void Array::emplace_back(Value element)
-{
-	m_elements.emplace_back(std::move(element));
-}
-
-Value& Array::operator[](size_t index)
-{
-	if (index + 1 > m_elements.size()) {
-		m_elements.resize(index + 1);
-	}
-
-	return m_elements[index];
-}
-
-} // namespace Json

src/util/json/array.h

@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_ARRAY_H
-#define JSON_ARRAY_H
-
-#include <utility> // move
-#include <vector>
-
-#include "util/json/parser.h"
-
-namespace Json {
-
-class Value;
-
-class Array {
-public:
-	Array() {}
-	virtual ~Array() {}
-
-	Array(const std::vector<Value>& elements)
-		: m_elements(elements)
-	{}
-
-	Array(const Array& other)
-		: m_elements(other.m_elements)
-	{
-	}
-
-	void clear() { m_elements.clear(); }
-	void emplace_back(Value element);
-	void reserve(size_t size) { m_elements.reserve(size); }
-
-	Value& operator[](size_t index);
-
-	Value& at(size_t index) { return m_elements.at(index); }
-	const Value& at(size_t index) const { return m_elements.at(index); }
-
-	size_t size() const { return m_elements.size(); }
-	const std::vector<Value>& elements() const { return m_elements; }
-
-private:
-	std::vector<Value> m_elements;
-};
-
-} // namespace Json
-
-#endif // JSON_ARRAY_H

src/util/json/conversion.h

@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_CONVERSION_H
-#define JSON_CONVERSION_H
-
-namespace Json {
-
-namespace Detail {
-
-// Avoid ODR (One Definition Rule) violations
-template<typename T>
-constexpr T staticConst {};
-
-} // namespace Detail
-
-} // namespace Json
-
-#endif // JSON_CONVERSION_H

src/util/json/fromjson.h

@@ -1,136 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_FROM_JSON_H
-#define JSON_FROM_JSON_H
-
-#include <algorithm> // transform
-#include <cassert>   // assert
-#include <cstddef>   // nullptr_t
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <utility> // forward
-#include <vector>
-
-#include "util/json/array.h"
-#include "util/json/conversion.h"
-#include "util/json/object.h"
-
-namespace Json {
-
-namespace Detail {
-
-// Required for containers with Json::Value type
-template<typename Json>
-void fromJson(const Json& json, Json& value)
-{
-	value = json;
-}
-
-template<typename Json>
-void fromJson(const Json& json, std::nullptr_t& null)
-{
-	assert(json.type() == Json::Type::Null);
-	null = nullptr;
-}
-
-template<typename Json>
-void fromJson(const Json& json, bool& boolean)
-{
-	assert(json.type() == Json::Type::Bool);
-	boolean = json.asBool();
-}
-
-template<typename Json>
-void fromJson(const Json& json, int& number)
-{
-	assert(json.type() == Json::Type::Number);
-	number = (int)json.asDouble();
-}
-
-template<typename Json>
-void fromJson(const Json& json, double& number)
-{
-	assert(json.type() == Json::Type::Number);
-	number = json.asDouble();
-}
-
-template<typename Json>
-void fromJson(const Json& json, std::string& string)
-{
-	assert(json.type() == Json::Type::String);
-	string = json.asString();
-}
-
-template<typename Json, typename T>
-void fromJson(const Json& json, std::vector<T>& array)
-{
-	assert(json.type() == Json::Type::Array);
-	array.resize(json.size());
-	std::transform(
-		json.asArray().elements().begin(),
-		json.asArray().elements().end(),
-		array.begin(),
-		[](const Json& json) {
-			return json.template get<T>(); // (missing-dependent-template-keyword)
-		});
-}
-
-template<typename Json, typename T>
-void fromJson(const Json& json, std::map<std::string, T>& object)
-{
-	assert(json.type() == Json::Type::Object);
-	object.clear();
-	for (const auto& [name, value] : json.asObject().members()) {
-		object.emplace(name, value.template get<T>());
-	}
-}
-
-template<typename Json, typename T>
-void fromJson(const Json& json, std::unordered_map<std::string, T>& object)
-{
-	assert(json.type() == Json::Type::Object);
-	object.clear();
-	for (const auto& [name, value] : json.asObject().members()) {
-		object.emplace(name, value.template get<T>());
-	}
-}
-
-struct fromJsonFunction {
-	template<typename Json, typename T>
-	auto operator()(const Json& json, T&& value) const
-	{
-		return fromJson(json, std::forward<T>(value));
-	}
-};
-
-} // namespace Detail
-
-// Anonymous namespace prevents multiple definition of the reference
-namespace {
-// Function object
-constexpr const auto& fromJson = Detail::staticConst<Detail::fromJsonFunction>; // NOLINT (misc-definitions-in-headers)
-} // namespace
-
-} // namespace Json
-
-#endif // JSON_FROM_JSON_H
-
-// Customization Points
-// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-
-// Json::fromJson is a function object, the type of which is
-// Json::Detail::fromJsonFunction. In the Json::Detail namespace are the
-// fromJson free functions. The function call operator of fromJsonFunction makes
-// an unqualified call to fromJson which, since it shares the Detail namespace
-// with the fromJson free functions, will consider those in addition to any
-// overloads that are found by argument-dependent lookup.
-
-// Variable templates are linked externally, therefor every translation unit
-// will see the same address for Detail::staticConst<Detail::fromJsonFunction>.
-// Since Json::fromJson is a reference to the variable template, it too will
-// have the same address in all translation units.

src/util/json/job.cpp

@@ -1,114 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <algorithm> // count
-#include <sstream>   // istringstream
-#include <string>    // getline
-
-#include "util/json/job.h"
-#include "util/json/lexer.h"
-#include "util/json/parser.h"
-#include "util/json/value.h"
-
-namespace Json {
-
-Job::Job(const std::string& input)
-	: m_input(input)
-{
-	// FIXME: Make this work for all newline types: \n, \r, \r\n
-	m_lineNumbersWidth = std::count(m_input.begin(), m_input.end(), '\n');
-	m_lineNumbersWidth += m_input.back() == '\n' ? 0 : 1;
-	m_lineNumbersWidth = std::to_string(m_lineNumbersWidth).length();
-}
-
-Job::~Job()
-{
-}
-
-// ------------------------------------------
-
-Value Job::fire()
-{
-	Lexer lexer(this);
-	lexer.analyze();
-
-	if (!m_success) {
-		return nullptr;
-	}
-
-	Parser parser(this);
-	Value value = parser.parse();
-
-	if (!m_success) {
-		return nullptr;
-	}
-
-	return value;
-}
-
-void Job::printErrorLine(Token token, const char* message)
-{
-	m_success = false;
-
-	// Error message
-	std::string errorFormat = "\033[;1m" // Bold
-							  "JSON:%zu:%zu: "
-							  "\033[31;1m" // Bold red
-							  "error: "
-							  "\033[0m" // Reset
-							  "%s"
-							  "\n";
-	fprintf(stderr,
-	        errorFormat.c_str(),
-	        token.line + 1,
-	        token.column + 1,
-	        message);
-
-	// Get the JSON line that caused the error
-	std::istringstream input(m_input);
-	std::string line;
-	for (size_t i = 0; std::getline(input, line); ++i) {
-		if (i == token.line) {
-			break;
-		}
-	}
-	// Replace tab indentation with spaces
-	size_t oldLineLength = line.length();
-	size_t tabs = line.find_first_not_of('\t');
-	if (tabs > 0 && tabs < line.size()) {
-		line = std::string(tabs * 4, ' ') + line.substr(tabs);
-	}
-	token.column += line.length() - oldLineLength;
-
-	// JSON line
-	std::string lineFormat = " %"
-	                         + std::to_string(m_lineNumbersWidth)
-	                         + "zu | "
-	                           "%s"
-	                           "\033[31;1m" // Bold red
-	                           "%s"
-	                           "\033[0m" // Reset
-	                           "\n";
-	fprintf(stderr,
-	        lineFormat.c_str(),
-	        token.line + 1,
-	        line.substr(0, token.column).c_str(),
-	        line.substr(token.column).c_str());
-
-	// Arrow pointer
-	std::string arrowFormat = " %s | "
-							  "\033[31;1m" // Bold red
-							  "%s^%s"
-							  "\033[0m" // Reset
-							  "\n";
-	fprintf(stderr,
-	        arrowFormat.c_str(),
-	        std::string(m_lineNumbersWidth, ' ').c_str(),
-	        std::string(token.column, ' ').c_str(),
-	        std::string(line.length() - token.column, '~').c_str());
-}
-
-} // namespace Json

src/util/json/job.h

@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_JOB_H
-#define JSON_JOB_H
-
-#include <cstddef> // size_t
-#include <string>
-#include <vector>
-
-#include "util/json/lexer.h"
-
-namespace Json {
-
-class Value;
-
-class Job {
-public:
-	Job(const std::string& input);
-	virtual ~Job();
-
-	enum class Color {
-		None,
-		Info,
-		Warn,
-		Danger,
-		Success,
-		Comment,
-	};
-
-	Value fire();
-
-	void printErrorLine(Token token, const char* message);
-
-	bool success() const { return m_success; }
-	const std::string& input() const { return m_input; }
-	std::vector<Token>* tokens() { return &m_tokens; }
-
-private:
-	bool m_success { true };
-
-	std::string m_input;
-	size_t m_lineNumbersWidth { 0 };
-
-	std::vector<Token> m_tokens;
-};
-
-} // namespace Json
-
-#endif // JSON_JOB_H

src/util/json/lexer.cpp

@@ -1,245 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <cstddef>
-#include <string>
-
-#include "util/json/job.h"
-#include "util/json/lexer.h"
-
-namespace Json {
-
-Lexer::Lexer(Job* job)
-	: m_job(job)
-	, m_tokens(job->tokens())
-{
-}
-
-Lexer::~Lexer()
-{
-}
-
-// -----------------------------------------
-
-void Lexer::analyze()
-{
-	while (m_index < m_job->input().length()) {
-		switch (peek()) {
-		case '{':
-			m_tokens->push_back({ Token::Type::BraceOpen, m_line, m_column, "{" });
-			break;
-		case '}':
-			m_tokens->push_back({ Token::Type::BraceClose, m_line, m_column, "}" });
-			break;
-		case '[':
-			m_tokens->push_back({ Token::Type::BracketOpen, m_line, m_column, "[" });
-			break;
-		case ']':
-			m_tokens->push_back({ Token::Type::BracketClose, m_line, m_column, "]" });
-			break;
-		case ':':
-			m_tokens->push_back({ Token::Type::Colon, m_line, m_column, ":" });
-			break;
-		case ',':
-			m_tokens->push_back({ Token::Type::Comma, m_line, m_column, "," });
-			break;
-		case '"':
-			if (!getString()) {
-				return;
-			}
-			break;
-		case '-':
-		case '0':
-		case '1':
-		case '2':
-		case '3':
-		case '4':
-		case '5':
-		case '6':
-		case '7':
-		case '8':
-		case '9':
-			if (!getNumber()) {
-				return;
-			}
-			break;
-		case 'a':
-		case 'b':
-		case 'c':
-		case 'd':
-		case 'e':
-		case 'f':
-		case 'g':
-		case 'h':
-		case 'i':
-		case 'j':
-		case 'k':
-		case 'l':
-		case 'm':
-		case 'n':
-		case 'o':
-		case 'p':
-		case 'q':
-		case 'r':
-		case 's':
-		case 't':
-		case 'u':
-		case 'v':
-		case 'w':
-		case 'x':
-		case 'y':
-		case 'z':
-			if (!getLiteral()) {
-				return;
-			}
-			break;
-		case ' ':
-		case '\t':
-			break;
-		case '\r':
-			if (peekNext() == '\n') { // CRLF \r\n
-				break;
-			}
-			m_column = -1;
-			m_line++;
-			break;
-		case '\n':
-			m_column = -1;
-			m_line++;
-			break;
-		default:
-			// Error!
-			m_tokens->push_back({ Token::Type::None, m_line, m_column, std::string(1, peek()) });
-			m_job->printErrorLine(m_tokens->back(),
-			                      (std::string() + "unexpected character '" + peek() + "'").c_str());
-			return;
-			break;
-		}
-
-		increment();
-	}
-}
-
-// -----------------------------------------
-
-char Lexer::peek()
-{
-	return m_job->input()[m_index];
-}
-
-char Lexer::peekNext()
-{
-	return m_job->input()[m_index + 1];
-}
-
-void Lexer::increment()
-{
-	m_index++;
-	m_column++;
-}
-
-void Lexer::decrement()
-{
-	m_index--;
-	m_column--;
-}
-
-char Lexer::consume()
-{
-	char character = peek();
-	increment();
-	return character;
-}
-
-bool Lexer::getString()
-{
-	size_t column = m_column;
-	std::string symbol = "";
-
-	bool escape = false;
-	char character = consume();
-	for (;;) {
-		character = peek();
-
-		if (!escape && character == '\\') {
-			symbol += '\\';
-			increment();
-			escape = true;
-			continue;
-		}
-
-		if (!escape &&
-		    (character == '"'
-		     || character == '\r'
-		     || character == '\n'
-		     || character == '\0')) {
-			break;
-		}
-
-		symbol += character;
-		increment();
-
-		if (escape) {
-			escape = false;
-		}
-	}
-
-	m_tokens->push_back({ Token::Type::String, m_line, column, symbol });
-
-	if (character != '"') {
-		m_job->printErrorLine(m_job->tokens()->back(), "strings should be wrapped in double quotes");
-		return false;
-	}
-
-	return true;
-}
-
-bool Lexer::getNumberOrLiteral(Token::Type type)
-{
-	size_t index = m_index;
-	size_t column = m_column;
-
-	for (char character;;) {
-		character = peek();
-
-		if (character == '{'
-		    || character == '}'
-		    || character == '['
-		    || character == ']'
-		    || character == ':'
-		    || character == ','
-		    || character == '"'
-		    || character == ' '
-		    || character == '\t'
-		    || character == '\r'
-		    || character == '\n'
-		    || character == '\0'
-		) {
-			break;
-		}
-
-		increment();
-	}
-
-	m_tokens->push_back({ type, m_line, column,
-	                      m_job->input().substr(index, m_index - index) });
-
-	decrement();
-
-	return true;
-}
-
-bool Lexer::getNumber()
-{
-	return getNumberOrLiteral(Token::Type::Number);
-}
-
-bool Lexer::getLiteral()
-{
-	return getNumberOrLiteral(Token::Type::Literal);
-}
-
-} // namespace Json

src/util/json/lexer.h

@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_LEXER_H
-#define JSON_LEXER_H
-
-// The JavaScript Object Notation (JSON) Data Interchange Format
-// https://www.rfc-editor.org/rfc/pdfrfc/rfc8259.txt.pdf
-
-#include <cstddef> // size_t
-#include <memory>  // shared_ptr
-#include <string>
-#include <vector>
-
-namespace Json {
-
-class Job;
-
-struct Token {
-	enum class Type {
-		None,
-		BraceOpen,    // {
-		BraceClose,   // }
-		BracketOpen,  // [
-		BracketClose, // ]
-		Colon,        // :
-		Comma,        // ,
-		String,       // "foobar"
-		Number,       // 123.456
-		Literal,      // false/null/true (case sensitive)
-	};
-
-	Type type { Type::None };
-	size_t line { 0 };
-	size_t column { 0 };
-	std::string symbol;
-};
-
-// Lexical analyzer
-class Lexer {
-public:
-	Lexer(Job* job);
-	virtual ~Lexer();
-
-	void analyze();
-
-private:
-	char peek();
-	char peekNext();
-
-	void increment();
-	void decrement();
-	char consume();
-
-	bool getString();
-	bool getNumberOrLiteral(Token::Type type);
-	bool getNumber();
-	bool getLiteral();
-
-	Job* m_job { nullptr };
-
-	size_t m_index { 0 };
-	size_t m_column { 0 };
-	size_t m_line { 0 };
-
-	std::vector<Token>* m_tokens { nullptr };
-};
-
-} // namespace Json
-
-#endif // JSON_LEXER_H

src/util/json/object.cpp

@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include "util/json/object.h"
-#include "util/json/value.h"
-
-namespace Json {
-
-void Object::emplace(const std::string& name, Value value)
-{
-	m_members.emplace(name, std::move(value));
-}
-
-Value& Object::operator[](const std::string& name)
-{
-	if (m_members.find(name) == m_members.end()) {
-		emplace(name, {});
-	}
-
-	return m_members.at(name);
-}
-
-} // namespace Json

src/util/json/object.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_OBJECT_H
-#define JSON_OBJECT_H
-
-#include <map>
-#include <string>
-#include <utility> // move
-
-#include "util/json/parser.h"
-
-namespace Json {
-
-class Value;
-
-class Object {
-public:
-	Object() {}
-	virtual ~Object() {}
-
-	Object(const Object& other)
-		: m_members(other.m_members)
-	{
-	}
-
-	void clear() { m_members.clear(); }
-	void emplace(const std::string& name, Value value);
-
-	Value& operator[](const std::string& name);
-
-	Value& at(const std::string& name) { return m_members.at(name); }
-	const Value& at(const std::string& name) const { return m_members.at(name); }
-
-	size_t size() const { return m_members.size(); }
-	const std::map<std::string, Value>& members() const { return m_members; }
-
-private:
-	std::map<std::string, Value> m_members;
-};
-
-} // namespace Json
-
-#endif // JSON_OBJECT_H

src/util/json/parser.cpp

@@ -1,498 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <algorithm> // count
-#include <cstddef>   // size_t
-#include <cstdint>   // uint8_t
-#include <cstdio>    // printf
-#include <map>
-#include <string> // stod
-
-#include "util/json/array.h"
-#include "util/json/job.h"
-#include "util/json/lexer.h"
-#include "util/json/object.h"
-#include "util/json/parser.h"
-#include "util/json/value.h"
-
-namespace Json {
-
-Parser::Parser(Job* job)
-	: m_job(job)
-	, m_tokens(m_job->tokens())
-{
-}
-
-Parser::~Parser()
-{
-}
-
-// -----------------------------------------
-
-Value Parser::parse()
-{
-	Value result;
-
-	if (m_tokens->size() == 0) {
-		m_job->printErrorLine({}, "expecting token, not 'EOF'");
-		return result;
-	}
-
-	Token token = peek();
-	switch (token.type) {
-	case Token::Type::Literal:
-		result = getLiteral();
-		break;
-	case Token::Type::Number:
-		result = getNumber();
-		break;
-	case Token::Type::String:
-		result = getString();
-		break;
-	case Token::Type::BracketOpen:
-		result = getArray();
-		break;
-	case Token::Type::BraceOpen:
-		result = getObject();
-		break;
-	case Token::Type::BracketClose:
-		m_job->printErrorLine(token, "expecting value, not ']'");
-		m_index++;
-		break;
-	case Token::Type::BraceClose:
-		m_job->printErrorLine(token, "expecting string, not '}'");
-		m_index++;
-		break;
-	default:
-		m_job->printErrorLine(token, "multiple root elements");
-		m_index++;
-		break;
-	}
-
-	if (!reachedEnd()) {
-		m_job->printErrorLine(peek(), "multiple root elements");
-	}
-
-	return result;
-}
-
-// -----------------------------------------
-
-bool Parser::reachedEnd()
-{
-	return m_index >= m_tokens->size();
-}
-
-bool Parser::seekForward(Token::Type type)
-{
-	for (; !reachedEnd(); ++m_index) {
-		if (peek().type == type) {
-			m_index++;
-			return true;
-		}
-	}
-
-	return false;
-}
-
-Token Parser::peek()
-{
-	return m_tokens->at(m_index);
-}
-
-Token Parser::consume()
-{
-	Token token = peek();
-	m_index++;
-	return token;
-}
-
-Value Parser::getLiteral()
-{
-	Token token = consume();
-
-	if (token.symbol == "null") {
-		return nullptr;
-	}
-	else if (token.symbol == "true") {
-		return true;
-	}
-	else if (token.symbol == "false") {
-		return false;
-	}
-
-	m_job->printErrorLine(token, "invalid literal");
-	return nullptr;
-}
-
-Value Parser::getNumber()
-{
-	Token token = consume();
-
-	auto reportError = [this](Token token, const std::string& message) -> void {
-		m_job->printErrorLine(token, message.c_str());
-	};
-
-	// Validation
-	// number = [ minus ] int [ frac ] [ exp ]
-
-	size_t minusPrefix = token.symbol[0] == '-' ? 1 : 0;
-
-	// Leading 0s
-	if (token.symbol[minusPrefix] == '0'
-	    && token.symbol[minusPrefix + 1] > '0' && token.symbol[minusPrefix + 1] < '9') {
-		reportError(token, "invalid leading zero");
-		return nullptr;
-	}
-
-	enum class State {
-		Int,
-		Fraction,
-		Exponent
-	};
-
-	State state = State::Int;
-
-#define CHECK_IF_VALID_NUMBER                                                                  \
-	if (character < 48 || character > 57) {                                                    \
-		reportError(token, std::string() + "invalid number, unexpected '" + character + '\''); \
-		return nullptr;                                                                        \
-	}
-
-	size_t fractionPosition = 0;
-	size_t exponentPosition = 0;
-	size_t length = token.symbol.length();
-	for (size_t i = 0; i < length; ++i) {
-		char character = token.symbol[i];
-
-		// Int -> Fraction
-		if (character == '.' && state == State::Int) {
-			state = State::Fraction;
-			fractionPosition = i;
-			continue;
-		}
-		// Int/Fraction -> Exponent
-		else if ((character == 'e' || character == 'E') && state != State::Exponent) {
-			state = State::Exponent;
-			exponentPosition = i;
-			continue;
-		}
-
-		if (state == State::Int) {
-			if (character == '-') {
-				if (i == length - 1) {
-					reportError(token, "expected number after minus");
-					return nullptr;
-				}
-				if (i != 0) {
-					reportError(token, "invalid minus");
-					return nullptr;
-				}
-			}
-			else {
-				CHECK_IF_VALID_NUMBER;
-			}
-		}
-		else if (state == State::Fraction) {
-			CHECK_IF_VALID_NUMBER;
-		}
-		else if (state == State::Exponent) {
-			if (character == '-' || character == '+') {
-				if (i == length - 1) {
-					reportError(token, "expected number after plus/minus");
-					return nullptr;
-				}
-				if (i > exponentPosition + 1) {
-					reportError(token, "invalid plus/minus");
-					return nullptr;
-				}
-			}
-			else {
-				CHECK_IF_VALID_NUMBER;
-			}
-		}
-	}
-
-	if (fractionPosition != 0 || exponentPosition != 0) {
-		if (fractionPosition == exponentPosition - 1) {
-			reportError(token, "invalid exponent sign, expected number");
-			return nullptr;
-		}
-
-		if (fractionPosition == length - 1 || exponentPosition == length - 1) {
-			reportError(token, "invalid number");
-			return nullptr;
-		}
-	}
-
-	return std::stod(token.symbol);
-}
-
-Value Parser::getString()
-{
-	Token token = consume();
-
-	auto reportError = [this](Token token, const std::string& message) -> void {
-		m_job->printErrorLine(token, message.c_str());
-	};
-
-	// FIXME: support \u Unicode character escape sequence
-	auto getPrintableString = [](char character) -> std::string {
-		if (character == '"' || character == '\\' || character == '/'
-		    || (character >= 0 && character <= 31)) {
-			switch (character) {
-			case '"':
-				return "\\\"";
-				break;
-			case '\\':
-				return "\\\\";
-				break;
-			case '/':
-				return "/";
-				break;
-			case '\b':
-				return "\\b";
-				break;
-			case '\f':
-				return "\\f";
-				break;
-			case '\n':
-				return "\\n";
-				break;
-			case '\r':
-				return "\\r";
-				break;
-			case '\t':
-				return "\\t";
-				break;
-			default:
-				char buffer[7];
-				sprintf(buffer, "\\u%0.4X", character);
-				return std::string(buffer);
-				break;
-			}
-		}
-
-		return std::string() + character;
-	};
-
-	std::string string;
-
-	bool escape = false;
-	for (char character : token.symbol) {
-		if (!escape) {
-			if (character == '\\') {
-				escape = true;
-				continue;
-			}
-
-			if (character == '"' || (character >= 0 && character <= 31)) {
-				reportError(token, "invalid string, unescaped character found");
-				return nullptr;
-			}
-		}
-
-		string += getPrintableString(character);
-
-		if (escape) {
-			escape = false;
-		}
-	}
-
-	return string;
-}
-
-Value Parser::getArray()
-{
-	m_index++;
-
-	auto reportError = [this](Token token, const std::string& message) -> void {
-		m_job->printErrorLine(token, message.c_str());
-
-		// After an error, try to find the closing bracket
-		seekForward(Token::Type::BracketClose);
-	};
-
-	Value array = Value::Type::Array;
-	Token token;
-	for (;;) {
-		// EOF
-		if (reachedEnd()) {
-			reportError(m_tokens->at(m_index - 1), "expecting closing ']' at end");
-			break;
-		}
-
-		token = peek();
-		if (token.type == Token::Type::Literal) {
-			array.emplace_back(getLiteral());
-		}
-		else if (token.type == Token::Type::Number) {
-			array.emplace_back(getNumber());
-		}
-		else if (token.type == Token::Type::String) {
-			array.emplace_back(getString());
-		}
-		else if (token.type == Token::Type::BracketOpen) {
-			array.emplace_back(getArray());
-		}
-		else if (token.type == Token::Type::BraceOpen) {
-			array.emplace_back(getObject());
-		}
-		else if (token.type == Token::Type::BracketClose) {
-			// Trailing comma
-			if (array.m_value.array->size() > 0) {
-				reportError(m_tokens->at(m_index - 1), "invalid comma, expecting ']'");
-				break;
-			}
-		}
-		else {
-			reportError(token, "expecting value or ']', not '" + token.symbol + "'");
-			break;
-		}
-
-		// EOF
-		if (reachedEnd()) {
-			reportError(token, "expecting closing ']' at end");
-			break;
-		}
-
-		// Find , or ]
-		token = consume();
-		if (token.type == Token::Type::Comma) {
-			continue;
-		}
-		else if (token.type == Token::Type::BracketClose) {
-			break;
-		}
-		else {
-			reportError(m_tokens->at(m_index - 1), "expecting comma or ']', not '" + token.symbol + "'");
-			break;
-		}
-	}
-
-	return array;
-}
-
-Value Parser::getObject()
-{
-	m_index++;
-
-	auto reportError = [this](Token token, const std::string& message) -> void {
-		m_job->printErrorLine(token, message.c_str());
-
-		// After an error, try to find the closing brace
-		seekForward(Token::Type::BraceClose);
-	};
-
-	Value object = Value::Type::Object;
-	Token token;
-	std::string name;
-	std::map<std::string, uint8_t> unique;
-	for (;;) {
-		// EOF
-		if (reachedEnd()) {
-			reportError(m_tokens->at(m_index - 1), "expecting closing '}' at end");
-			break;
-		}
-
-		token = consume();
-		if (token.type == Token::Type::BraceClose) {
-			// Trailing comma
-			if (object.m_value.object->size() > 0) {
-				reportError(m_tokens->at(m_index - 1), "invalid comma, expecting '}'");
-			}
-			// Empty object
-			break;
-		}
-		if (token.type != Token::Type::String) {
-			reportError(token, "expecting string or '}', not '" + token.symbol + "'");
-			break;
-		}
-
-		// Find member name
-		m_index--;
-		Value tmpName = getString();
-		if (tmpName.m_type != Value::Type::String) {
-			seekForward(Token::Type::BraceClose);
-			break;
-		}
-
-		// Check if name exists in hashmap
-		name = *tmpName.m_value.string;
-		if (unique.find(name) != unique.end()) {
-			reportError(token, "duplicate name '" + token.symbol + "', names should be unique");
-			break;
-		}
-		// Add name to hashmap
-		unique.insert({ name, 0 });
-
-		// EOF
-		if (reachedEnd()) {
-			reportError(token, "expecting colon, not 'EOF'");
-			reportError(token, "expecting closing '}' at end");
-			break;
-		}
-
-		// Find :
-		token = consume();
-		if (token.type != Token::Type::Colon) {
-			reportError(token, "expecting colon, not '" + token.symbol + "'");
-			break;
-		}
-
-		// EOF
-		if (reachedEnd()) {
-			reportError(token, "expecting value, not 'EOF'");
-			reportError(token, "expecting closing '}' at end");
-			break;
-		}
-
-		// Add member (name:value pair) to object
-		token = peek();
-		if (token.type == Token::Type::Literal) {
-			object.emplace(name, getLiteral());
-		}
-		else if (token.type == Token::Type::Number) {
-			object.emplace(name, getNumber());
-		}
-		else if (token.type == Token::Type::String) {
-			object.emplace(name, getString());
-		}
-		else if (token.type == Token::Type::BracketOpen) {
-			object.emplace(name, getArray());
-		}
-		else if (token.type == Token::Type::BraceOpen) {
-			object.emplace(name, getObject());
-		}
-		else {
-			reportError(token, "expecting value, not '" + token.symbol + "'");
-			break;
-		}
-
-		// EOF
-		if (reachedEnd()) {
-			reportError(token, "expecting closing '}' at end");
-			break;
-		}
-
-		// Find , or }
-		token = consume();
-		if (token.type == Token::Type::Comma) {
-			continue;
-		}
-		else if (token.type == Token::Type::BraceClose) {
-			break;
-		}
-		else {
-			reportError(token, "expecting comma or '}', not '" + token.symbol + "'");
-			break;
-		}
-	}
-
-	return object;
-}
-
-} // namespace Json

src/util/json/parser.h

@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_PARSER_H
-#define JSON_PARSER_H
-
-#include <cstddef> // size_t
-#include <vector>
-
-#include "util/json/lexer.h"
-
-namespace Json {
-
-class Job;
-class Value;
-
-class Parser {
-public:
-	Parser(Job* job);
-	virtual ~Parser();
-
-	Value parse();
-
-private:
-	bool reachedEnd();
-	bool seekForward(Token::Type type);
-
-	Token peek();
-	Token consume();
-
-	Value getLiteral();
-	Value getNumber();
-	Value getString();
-	Value getArray();
-	Value getObject();
-
-	Job* m_job { nullptr };
-
-	size_t m_index { 0 };
-
-	std::vector<Token>* m_tokens { nullptr };
-};
-
-} // namespace Json
-
-#endif // JSON_PARSER_H

src/util/json/serializer.cpp

@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <cstdint>  // uint32_t
-#include <iterator> // prev
-#include <sstream>  // ostringstream
-#include <string>
-
-#include "util/json/array.h"
-#include "util/json/lexer.h"
-#include "util/json/object.h"
-#include "util/json/serializer.h"
-
-namespace Json {
-
-Serializer::Serializer(const Value& value, const uint32_t indent, const char indentCharacter)
-	: m_value(value)
-	, m_indent(indent)
-	, m_indentCharacter(indentCharacter)
-{
-}
-
-Serializer::~Serializer()
-{
-}
-
-// ------------------------------------------
-
-std::string Serializer::dump()
-{
-	return dumpHelper(m_value);
-}
-
-// ------------------------------------------
-
-std::string Serializer::dumpHelper(const Value& value, const uint32_t indentLevel)
-{
-	switch (value.m_type) {
-	case Value::Type::Null:
-		return "null";
-		break;
-	case Value::Type::Bool:
-		return value.m_value.boolean ? "true" : "false";
-		break;
-	case Value::Type::Number: {
-		std::ostringstream os;
-		os << value.m_value.number;
-		return os.str();
-		break;
-	}
-	case Value::Type::String:
-		return "\"" + *value.m_value.string + "\"";
-		break;
-	case Value::Type::Array:
-		return dumpArray(value, indentLevel);
-		break;
-	case Value::Type::Object:
-		return dumpObject(value, indentLevel);
-		break;
-	default:
-		break;
-	}
-
-	return "";
-}
-
-std::string Serializer::dumpArray(const Value& value, const uint32_t indentLevel)
-{
-	std::string result;
-
-	// Append [
-	result += "[";
-	if (m_indent > 0) {
-		result += '\n';
-	}
-
-	auto values = value.m_value.array->elements();
-	for (auto it = values.begin(); it != values.end(); ++it) {
-		result += std::string(m_indent * (indentLevel + 1), m_indentCharacter);
-		result += dumpHelper(*it, indentLevel + 1);
-
-		// Add comma, except after the last element
-		if (it != std::prev(values.end(), 1)) {
-			result += ",";
-		}
-		if (m_indent > 0) {
-			result += '\n';
-		}
-	}
-
-	// Append indentation
-	result += std::string(m_indent * indentLevel, m_indentCharacter);
-
-	// Append ]
-	result += "]";
-
-	return result;
-}
-
-std::string Serializer::dumpObject(const Value& value, const uint32_t indentLevel)
-{
-	std::string result;
-
-	// Append {
-	result += "{";
-	if (m_indent > 0) {
-		result += '\n';
-	}
-
-	auto members = value.m_value.object->members();
-	for (auto it = members.begin(); it != members.end(); ++it) {
-		result += std::string(m_indent * (indentLevel + 1), m_indentCharacter);
-		result += "\"" + it->first + "\":";
-		if (m_indent > 0) {
-			result += ' ';
-		}
-		result += dumpHelper(it->second, indentLevel + 1);
-
-		// Add comma, except after the last element
-		if (it != std::prev(members.end(), 1)) {
-			result += ",";
-		}
-		if (m_indent > 0) {
-			result += '\n';
-		}
-	}
-
-	// Append indentation
-	result += std::string(m_indent * indentLevel, m_indentCharacter);
-
-	// Append }
-	result += "}";
-
-	return result;
-}
-
-} // namespace Json

src/util/json/serializer.h

@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_SERIALIZER_H
-#define JSON_SERIALIZER_H
-
-#include <cstdint> // uint32_t
-#include <string>
-
-#include "util/json/value.h"
-
-namespace Json {
-
-class Serializer {
-public:
-	Serializer(const Value& value, const uint32_t indent = 0, const char indentCharacter = ' ');
-	virtual ~Serializer();
-
-	std::string dump();
-
-private:
-	std::string dumpHelper(const Value& value, const uint32_t indentLevel = 0);
-	std::string dumpArray(const Value& value, const uint32_t indentLevel = 0);
-	std::string dumpObject(const Value& value, const uint32_t indentLevel = 0);
-
-	Value m_value;
-
-	uint32_t m_indent { 0 };
-	char m_indentCharacter { ' ' };
-};
-
-} // namespace Json
-
-#endif // JSON_SERIALIZER_H

src/util/json/tojson.h

@@ -1,156 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_TO_JSON_H
-#define JSON_TO_JSON_H
-
-#include <cassert> // assert
-#include <cstddef> // nullptr_t
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <utility> // forward
-
-#include "util/json/array.h"
-#include "util/json/conversion.h"
-#include "util/json/object.h"
-
-namespace Json {
-
-namespace Detail {
-
-struct jsonConstructor {
-	template<typename Json>
-	static void construct(Json& json, bool boolean)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Bool;
-		json.m_value.boolean = boolean;
-	}
-
-	template<typename Json>
-	static void construct(Json& json, int number)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Number;
-		json.m_value.number = (double)number;
-	}
-
-	template<typename Json>
-	static void construct(Json& json, double number)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Number;
-		json.m_value.number = number;
-	}
-
-	template<typename Json>
-	static void construct(Json& json, const char* string)
-	{
-		json.destroy();
-		json.m_type = Json::Type::String;
-		json.m_value.string = new std::string(string);
-	}
-
-	template<typename Json>
-	static void construct(Json& json, const std::string& string)
-	{
-		json.destroy();
-		json.m_type = Json::Type::String;
-		json.m_value.string = new std::string(string);
-	}
-
-	template<typename Json>
-	static void construct(Json& json, const Array& array)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Array;
-		json.m_value.array = new Array(array);
-	}
-
-	template<typename Json, typename T>
-	static void construct(Json& json, const std::vector<T>& array)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Array;
-		json.m_value.array = new Array;
-		json.m_value.array->reserve(array.size());
-		for (const T& value : array) {
-			json.m_value.array->emplace_back(value);
-		}
-	}
-
-	template<typename Json>
-	static void construct(Json& json, const Object& object)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Object;
-		json.m_value.object = new Object(object);
-	}
-
-	template<typename Json, typename T>
-	static void construct(Json& json, const std::map<std::string, T>& object)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Object;
-		json.m_value.object = new Object;
-		for (const auto& [name, value] : object) {
-			json.m_value.object->emplace(name, value);
-		}
-	}
-
-	template<typename Json, typename T>
-	static void construct(Json& json, const std::unordered_map<std::string, T>& object)
-	{
-		json.destroy();
-		json.m_type = Json::Type::Object;
-		json.m_value.object = new Object;
-		for (const auto& [name, value] : object) {
-			json.m_value.object->emplace(name, value);
-		}
-	}
-};
-
-template<typename Json, typename T>
-void toJson(Json& json, const T& value)
-{
-	jsonConstructor::construct(json, value);
-}
-
-struct toJsonFunction {
-	template<typename Json, typename T>
-	auto operator()(Json& json, T&& value) const
-	{
-		return toJson(json, std::forward<T>(value));
-	}
-};
-
-} // namespace Detail
-
-// Anonymous namespace prevents multiple definition of the reference
-namespace {
-// Function object
-constexpr const auto& toJson = Detail::staticConst<Detail::toJsonFunction>; // NOLINT (misc-definitions-in-headers)
-} // namespace
-
-} // namespace Json
-
-#endif // JSON_TO_JSON_H
-
-// Customization Points
-// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-
-// Json::toJson is a function object, the type of which is
-// Json::Detail::toJsonFunction. In the Json::Detail namespace are the toJson
-// free functions. The function call operator of toJsonFunction makes an
-// unqualified call to toJson which, since it shares the Detail namespace with
-// the toJson free functions, will consider those in addition to any overloads
-// that are found by argument-dependent lookup.
-
-// Variable templates are linked externally, therefor every translation unit
-// will see the same address for Detail::staticConst<Detail::toJsonFunction>.
-// Since Json::toJson is a reference to the variable template, it too will have
-// the same address in all translation units.

src/util/json/value.cpp

@@ -1,327 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <algorithm> // all_of
-#include <cassert>   // assert
-#include <cstdint>   // uint32_t
-#include <iostream>  // istream, ostream
-#include <string>
-#include <utility> // move, swap
-
-#include "util/json/array.h"
-#include "util/json/job.h"
-#include "util/json/object.h"
-#include "util/json/serializer.h"
-#include "util/json/value.h"
-
-namespace Json {
-
-Value::Value(std::nullptr_t)
-	: Value(Type::Null)
-{
-}
-
-Value::Value(Type type)
-	: m_type(type)
-{
-	switch (m_type) {
-	case Type::Bool:
-		m_value.boolean = false;
-		break;
-	case Type::Number:
-		m_value.number = 0.0;
-		break;
-	case Type::String:
-		m_value.string = new std::string;
-		break;
-	case Type::Array:
-		m_value.array = new Array;
-		break;
-	case Type::Object:
-		m_value.object = new Object;
-		break;
-	case Type::Null:
-	default:
-		break;
-	}
-}
-
-Value::Value(const std::initializer_list<Value>& values)
-{
-	bool isObject = std::all_of(values.begin(), values.end(), [](const Value& value) {
-		return value.type() == Type::Array
-		       && value.size() == 2
-		       && value[0].m_type == Type::String;
-	});
-
-	if (!isObject) {
-		m_type = Type::Array;
-		m_value.array = new Array(values);
-	}
-	else {
-		m_type = Type::Object;
-		m_value.object = new Object;
-
-		for (auto& value : values) {
-			m_value.object->emplace(std::move(*value[0].m_value.string),
-			                        std::move(value[1]));
-		}
-	}
-}
-
-// Copy constructor
-Value::Value(const Value& other)
-	: m_type(other.m_type)
-{
-	switch (m_type) {
-	case Type::Bool:
-		m_value.boolean = other.m_value.boolean;
-		break;
-	case Type::Number:
-		m_value.number = other.m_value.number;
-		break;
-	case Type::String:
-		m_value.string = new std::string(*other.m_value.string);
-		break;
-	case Type::Array:
-		m_value.array = new Array(*other.m_value.array);
-		break;
-	case Type::Object:
-		m_value.object = new Object(*other.m_value.object);
-		break;
-	case Type::Null:
-	default:
-		break;
-	}
-}
-
-// Move constructor
-Value::Value(Value&& other) noexcept
-	: Value(Type::Null) // Initialize via default construction
-{
-	// Allow std::swap as a fallback on ADL failure
-	using std::swap;
-	// Unqualified call to swap, allow ADL to operate and find best match
-	swap(*this, other);
-}
-
-// Copy assignment
-// Move assignment
-Value& Value::operator=(Value other)
-{
-	// Allow std::swap as a fallback on ADL failure
-	using std::swap;
-	// Unqualified call to swap, allow ADL to operate and find best match
-	swap(*this, other);
-
-	return *this;
-}
-
-void swap(Value& left, Value& right) noexcept
-{
-	std::swap(left.m_type, right.m_type);
-	std::swap(left.m_value, right.m_value);
-}
-
-// ------------------------------------------
-
-void Value::clear()
-{
-	switch (m_type) {
-	case Type::Bool:
-		m_value.boolean = false;
-		break;
-	case Type::Number:
-		m_value.number = 0.0;
-		break;
-	case Type::String:
-		m_value.string->clear();
-		break;
-	case Type::Array:
-		m_value.array->clear();
-		break;
-	case Type::Object:
-		m_value.object->clear();
-		break;
-	case Type::Null:
-	default:
-		break;
-	}
-}
-
-Value Value::parse(const std::string& input)
-{
-	return Job(input).fire();
-}
-
-std::string Value::dump(const uint32_t indent, const char indentCharacter) const
-{
-	Serializer serializer(*this, indent, indentCharacter);
-	return serializer.dump();
-}
-
-void Value::emplace_back(Value value)
-{
-	// Implicitly convert null to an array
-	if (m_type == Type::Null) {
-		m_type = Type::Array;
-		m_value.array = new Array;
-	}
-
-	assert(m_type == Type::Array);
-	m_value.array->emplace_back(value);
-}
-
-void Value::emplace(const std::string& key, Value value)
-{
-	// Implicitly convert null to an object
-	if (m_type == Type::Null) {
-		m_type = Type::Object;
-		m_value.object = new Object;
-	}
-
-	assert(m_type == Type::Object);
-	m_value.object->emplace(key, value);
-}
-
-bool Value::exists(size_t index) const
-{
-	return index < size();
-}
-
-bool Value::exists(const std::string& key) const
-{
-	assert(m_type == Type::Object);
-	return m_value.object->members().find(key) != m_value.object->members().end();
-}
-
-// ------------------------------------------
-
-Value& Value::operator[](size_t index)
-{
-	// Implicitly convert null to an array
-	if (m_type == Type::Null) {
-		m_type = Type::Array;
-		m_value.array = new Array;
-	}
-
-	assert(m_type == Type::Array);
-	return (*m_value.array)[index];
-}
-
-Value& Value::operator[](const std::string& key)
-{
-	// Implicitly convert null to an object
-	if (m_type == Type::Null) {
-		m_type = Type::Object;
-		m_value.object = new Object;
-	}
-
-	assert(m_type == Type::Object);
-	return (*m_value.object)[key];
-}
-
-const Value& Value::operator[](size_t index) const
-{
-	assert(m_type == Type::Array);
-	return (*m_value.array)[index];
-}
-
-const Value& Value::operator[](const std::string& key) const
-{
-	assert(m_type == Type::Object);
-	return (*m_value.object)[key];
-}
-
-Value& Value::at(size_t index)
-{
-	assert(m_type == Type::Array);
-	return m_value.array->at(index);
-}
-
-Value& Value::at(const std::string& key)
-{
-	assert(m_type == Type::Object);
-	return m_value.object->at(key);
-}
-
-const Value& Value::at(size_t index) const
-{
-	assert(m_type == Type::Array);
-	return m_value.array->at(index);
-}
-
-const Value& Value::at(const std::string& key) const
-{
-	assert(m_type == Type::Object);
-	return m_value.object->at(key);
-}
-
-// ------------------------------------------
-
-size_t Value::size() const
-{
-	switch (m_type) {
-	case Type::Null:
-		return 0;
-	case Type::Array:
-		return m_value.array->size();
-	case Type::Object:
-		return m_value.object->size();
-	case Type::Bool:
-	case Type::Number:
-	case Type::String:
-	default:
-		return 1;
-	}
-}
-
-// ------------------------------------------
-
-void Value::destroy()
-{
-	switch (m_type) {
-	case Type::String:
-		delete m_value.string;
-		break;
-	case Type::Array:
-		delete m_value.array;
-		break;
-	case Type::Object:
-		delete m_value.object;
-		break;
-	case Type::Null:
-	case Type::Bool:
-	case Type::Number:
-	default:
-		break;
-	}
-}
-
-// ------------------------------------------
-
-std::istream& operator>>(std::istream& input, Value& value)
-{
-	std::string inputString;
-
-	char buffer[4096];
-	while (input.read(buffer, sizeof(buffer))) {
-		inputString.append(buffer, sizeof(buffer));
-	}
-	inputString.append(buffer, input.gcount());
-
-	Job job(inputString);
-	value = job.fire();
-
-	return input;
-}
-
-std::ostream& operator<<(std::ostream& output, const Value& value)
-{
-	return output << value.dump(4);
-}
-
-} // namespace Json

src/util/json/value.h

@@ -1,148 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef JSON_VALUE_H
-#define JSON_VALUE_H
-
-#include <cstddef> // nullptr_t, size_t
-#include <cstdint> // uint32_t
-#include <initializer_list>
-#include <iostream> // istream, ostream
-#include <string>
-#include <utility> // forward
-
-#include "util/json/fromjson.h"
-#include "util/json/tojson.h"
-
-namespace Json {
-
-class Array;
-class Object;
-
-class Value {
-private:
-	friend Detail::jsonConstructor;
-	friend class Parser;
-	friend class Serializer;
-
-public:
-	enum class Type {
-		Null,   // null       (case sensitive!)
-		Bool,   // true/false (case sensitive!)
-		Number, // 123
-		String, // ""
-		Array,  // []
-		Object, // {}
-	};
-
-	// --------------------------------------
-
-	// Constructors
-	Value(std::nullptr_t = nullptr);
-	Value(Type type);
-	Value(const std::initializer_list<Value>& values);
-	template<typename T>
-	Value(T value)
-	{
-		toJson(*this, std::forward<T>(value));
-	}
-
-	// Rule of Five:
-	// Copy constructor
-	Value(const Value& other);
-	// Move constructor
-	Value(Value&& other) noexcept;
-	// Copy assignment
-	// Move assignment
-	Value& operator=(Value other);
-	// Destructor
-	virtual ~Value() { destroy(); }
-
-	friend void swap(Value& left, Value& right) noexcept;
-
-	// --------------------------------------
-
-	static Value parse(const std::string& input);
-	std::string dump(const uint32_t indent = 0, const char indentCharacter = ' ') const;
-
-	void clear();
-
-	void emplace_back(Value value);
-	void emplace(const std::string& key, Value value);
-
-	bool exists(size_t index) const;
-	bool exists(const std::string& key) const;
-
-	// --------------------------------------
-
-	// Array index operator
-	Value& operator[](size_t index);
-	Value& operator[](const std::string& key);
-	const Value& operator[](size_t index) const;
-	const Value& operator[](const std::string& key) const;
-
-	Value& at(size_t index);
-	Value& at(const std::string& key);
-	const Value& at(size_t index) const;
-	const Value& at(const std::string& key) const;
-
-	// --------------------------------------
-
-	template<typename T>
-	T get() const
-	{
-		T type;
-		fromJson(*this, type);
-		return type;
-	}
-
-	template<typename T>
-	void getTo(T& type) const
-	{
-		fromJson(*this, type);
-	}
-
-	// --------------------------------------
-
-	Type type() const { return m_type; }
-	size_t size() const;
-
-	bool asBool() const { return m_value.boolean; }
-	double asDouble() const { return m_value.number; }
-	const std::string& asString() const { return *m_value.string; }
-	const Array& asArray() const { return *m_value.array; }
-	const Object& asObject() const { return *m_value.object; }
-
-private:
-	void destroy();
-
-	Type m_type { Type::Null };
-
-	union {
-		bool boolean;
-		double number;
-		std::string* string;
-		Array* array;
-		Object* object;
-	} m_value {};
-};
-
-std::istream& operator>>(std::istream& input, Value& value);
-std::ostream& operator<<(std::ostream& output, const Value& value);
-
-} // namespace Json
-
-/**
- * User-defined string literal
- *
- * Example usage: auto json = "[ 3.14, true, null ]"_json;
- */
-inline Json::Value operator"" _json(const char* input, size_t length)
-{
-	return Json::Value::parse(std::string(input, length));
-}
-
-#endif // JSON_VALUE_H

src/util/shell.cpp

@@ -1,53 +0,0 @@
-#include <cstdio> // pclose, perror, popen
-#include <string>
-#include <string_view>
-
-#include "util/shell.h"
-
-namespace Util {
-
-Shell::Shell()
-{
-}
-
-Shell::Shell(const std::string& output, int status)
-	: m_output(output)
-	, m_status(status)
-{
-}
-
-Shell Shell::operator()(const char* command)
-{
-	FILE* shell = popen(command, "r");
-	if (!shell) {
-		perror("\033[31;1mError:\033[0m popen");
-		return { "", -1 };
-	}
-
-	std::string output;
-
-	constexpr int bufferSize = 4096;
-	char buffer[bufferSize];
-	while (fgets(buffer, sizeof(buffer), shell)) {
-		output.append(buffer);
-	}
-
-	int status = pclose(shell);
-	if (status < 0) {
-		perror("\033[31;1mError:\033[0m pclose");
-	}
-
-	return { output, status };
-}
-
-Shell Shell::operator()(std::string command)
-{
-	return operator()(command.c_str());
-}
-
-Shell Shell::operator()(std::string_view command)
-{
-	return operator()(command.data());
-}
-
-} // namespace Util

src/util/shell.h

@@ -1,30 +0,0 @@
-#ifndef SHELL_H
-#define SHELL_H
-
-#include <string>
-#include <string_view>
-
-namespace Util {
-
-class Shell {
-public:
-	Shell();
-	virtual ~Shell() {}
-
-	Shell operator()(const char* command);
-	Shell operator()(std::string command);
-	Shell operator()(std::string_view command);
-
-	std::string output() const { return m_output; }
-	int status() const { return m_status; }
-
-private:
-	Shell(const std::string& output, int status);
-
-	std::string m_output;
-	int m_status { 0 };
-};
-
-} // namespace Util
-
-#endif // SHELL_H

src/util/singleton.h

@@ -1,50 +0,0 @@
-#ifndef SINGLETON_H
-#define SINGLETON_H
-
-#include <cassert>
-
-namespace Util {
-
-template<typename T>
-class Singleton {
-public:
-	static inline T& the()
-	{
-		if (s_instance == nullptr) {
-			s_instance = new T { s {} };
-		}
-
-		return *s_instance;
-	}
-
-	static inline void destroy()
-	{
-		if (s_instance) {
-			delete s_instance;
-		}
-
-		s_instance = nullptr;
-	}
-
-	// Remove copy constructor and copy assignment operator
-	Singleton(const Singleton&) = delete;
-	Singleton& operator=(const Singleton&) = delete;
-	Singleton(Singleton&&) = delete;
-	Singleton& operator=(Singleton&&) = delete;
-
-protected:
-	Singleton() {}
-
-	// Constructor token
-	struct s {};
-
-private:
-	static T* s_instance;
-};
-
-template<typename T>
-T* Singleton<T>::s_instance = nullptr;
-
-} // namespace Util
-
-#endif // SINGLETON_H

src/util/system.cpp

@@ -1,328 +0,0 @@
-#include <cerrno>     // errno, EAGAIN, EINTR
-#include <cstddef>    // size_t
-#include <cstdio>     // perror, ssize_t
-#include <cstdlib>    // exit, WEXITSTATUS
-#include <cstring>    // strcpy, strtok
-#include <functional> // function
-#include <sstream>    // istringstream
-#include <string>
-#include <string_view>
-#include <sys/wait.h> // waitpid
-#include <unistd.h>   // close, dup2, execvp, fork, pipe, read
-#include <vector>
-
-#include "util/system.h"
-
-namespace Util {
-
-System::System()
-{
-}
-
-System::System(const std::vector<std::string>& arguments)
-	: m_arguments(arguments)
-{
-}
-
-System System::operator()()
-{
-	return exec();
-}
-
-System System::operator()(const char* command)
-{
-	return operator()(std::string { command });
-}
-
-System System::operator()(std::string command)
-{
-	std::vector<std::string> arguments;
-
-	size_t index = 0;
-	while (index != std::string::npos) {
-		index = command.find_first_of(" ");
-		arguments.push_back(command.substr(0, index));
-		command = command.substr(index + 1);
-	}
-
-	return { arguments };
-}
-
-System System::operator()(std::string_view command)
-{
-	return operator()(std::string { command });
-}
-
-System System::operator()(const std::vector<const char*>& arguments)
-{
-	std::vector<std::string> stringArguments(arguments.size(), "");
-	for (size_t i = 0; i < arguments.size(); ++i) {
-		stringArguments[i] = arguments[i];
-	}
-
-	return { stringArguments };
-}
-
-System System::operator()(const std::vector<std::string>& arguments)
-{
-	return { arguments };
-}
-
-System System::operator()(const std::vector<std::string_view>& arguments)
-{
-	std::vector<std::string> stringArguments(arguments.size(), "");
-	for (size_t i = 0; i < arguments.size(); ++i) {
-		stringArguments[i] = arguments[i];
-	}
-
-	return { stringArguments };
-}
-
-// Shell equivalent ;
-System System::operator+(System rhs)
-{
-	auto lhs = *this;
-
-	lhs.exec();
-	rhs.m_output.append(lhs.m_output);
-	rhs.m_error.append(lhs.m_error);
-	rhs.exec();
-
-	return rhs;
-}
-
-System System::operator|(System rhs)
-{
-	auto lhs = *this;
-
-	lhs.exec();
-	rhs.exec(lhs.m_output);
-
-	return rhs;
-}
-
-System System::operator&&(System rhs)
-{
-	auto lhs = *this;
-
-	lhs.exec();
-	if (lhs.m_status > 0) {
-		return lhs;
-	}
-
-	rhs.m_output.append(lhs.m_output);
-	rhs.m_error.append(lhs.m_error);
-	rhs.exec();
-
-	return rhs;
-}
-
-System System::operator||(System rhs)
-{
-	auto lhs = *this;
-
-	lhs.exec();
-	if (lhs.m_status == 0) {
-		return lhs;
-	}
-
-	rhs.m_output.append(lhs.m_output);
-	rhs.m_error.append(lhs.m_error);
-	rhs.exec();
-
-	return rhs;
-}
-
-// cut -f -d
-System& System::cut(uint32_t field, char delimiter)
-{
-	exec();
-
-	return apply([&field, &delimiter](std::vector<std::string>& lines) {
-		for (auto& line : lines) {
-			size_t count = 1;
-			size_t index = 0;
-			while (index != std::string::npos) {
-				if (count == field) {
-					line = line.substr(0, line.find_first_of(delimiter));
-					break;
-				}
-
-				index = line.find_first_of(delimiter);
-				line = line.substr(index + 1);
-				count++;
-			}
-		}
-	});
-}
-
-System& System::sort(bool unique)
-{
-	exec();
-
-	return apply([&unique](std::vector<std::string>& lines) {
-		std::sort(lines.begin(), lines.end());
-
-		if (unique) {
-			auto last = std::unique(lines.begin(), lines.end());
-			lines.erase(last, lines.end());
-		}
-	});
-}
-
-// tail -n
-System& System::tail(int32_t number, bool starting)
-{
-	exec();
-
-	return apply([&number, &starting](std::vector<std::string>& lines) {
-		number = abs(number);
-		if (!starting) {
-			lines.erase(lines.begin(), lines.end() - number);
-		}
-		else {
-			lines.erase(lines.begin(), lines.begin() + number - 1);
-		}
-	});
-}
-
-System& System::apply(LineCallback callback)
-{
-	exec();
-
-	std::vector<std::string> lines;
-
-	auto stream = std::istringstream(m_output);
-	std::string line;
-	while (std::getline(stream, line)) {
-		lines.push_back(line);
-	}
-
-	callback(lines);
-
-	m_output.clear();
-	for (size_t i = 0; i < lines.size(); ++i) {
-		m_output.append(lines.at(i) + '\n');
-	}
-
-	return *this;
-}
-
-void System::print(const std::vector<std::string>& arguments)
-{
-	if (!arguments.size()) {
-		return;
-	}
-
-	printf("----------\n");
-	printf("size:    %zu\n", arguments.size());
-	printf("command: ");
-	for (size_t i = 0; i < arguments.size(); ++i) {
-		printf("%s ", arguments.at(i).c_str());
-	}
-	printf("\n");
-	printf("----------\n");
-}
-
-// -----------------------------------------
-
-System System::exec(std::string input)
-{
-	if (m_arguments.empty()) {
-		return *this;
-	}
-
-	int stdinFd[2];
-	int stdoutFd[2];
-	int stderrFd[2];
-	if (pipe(stdinFd) < 0) {
-		perror("\033[31;1mError:\033[0m pipe");
-	}
-	if (pipe(stdoutFd) < 0) {
-		perror("\033[31;1mError:\033[0m pipe");
-	}
-	if (pipe(stderrFd) < 0) {
-		perror("\033[31;1mError:\033[0m pipe");
-	}
-
-	pid_t pid = fork();
-	switch (pid) {
-	// Failed
-	case -1:
-		perror("\033[31;1mError:\033[0m fork");
-		break;
-	// Child
-	case 0: {
-		close(stdinFd[WriteFileDescriptor]);
-		dup2(stdinFd[ReadFileDescriptor], fileno(stdin));
-		close(stdinFd[ReadFileDescriptor]);
-
-		close(stdoutFd[ReadFileDescriptor]);
-		dup2(stdoutFd[WriteFileDescriptor], fileno(stdout));
-		close(stdoutFd[WriteFileDescriptor]);
-
-		close(stderrFd[ReadFileDescriptor]);
-		dup2(stderrFd[WriteFileDescriptor], fileno(stderr));
-		close(stderrFd[WriteFileDescriptor]);
-
-		std::vector<char*> charArguments(m_arguments.size() + 1, 0);
-		for (size_t i = 0; i < m_arguments.size(); ++i) {
-			charArguments[i] = const_cast<char*>(m_arguments[i].c_str());
-		}
-
-		execvp(charArguments[0], &charArguments[0]);
-		exit(0);
-	}
-	// Parent
-	default:
-		m_arguments.clear();
-		break;
-	}
-
-	close(stdinFd[ReadFileDescriptor]);
-	if (!input.empty()) {
-		write(stdinFd[WriteFileDescriptor], input.c_str(), input.size());
-	}
-	close(stdinFd[WriteFileDescriptor]);
-
-	readFromFileDescriptor(stdoutFd, m_output);
-	readFromFileDescriptor(stderrFd, m_error);
-
-	int result;
-	do {
-		result = waitpid(pid, &m_status, 0);
-	} while (result == -1 && errno == EINTR);
-	m_status = WEXITSTATUS(m_status);
-
-	return *this;
-}
-
-void System::readFromFileDescriptor(int fileDescriptor[2], std::string& output)
-{
-	close(fileDescriptor[WriteFileDescriptor]);
-
-	constexpr int bufferSize = 4096;
-	char buffer[bufferSize];
-
-	for (;;) {
-		const ssize_t result = read(fileDescriptor[ReadFileDescriptor], buffer, bufferSize);
-		if (result > 0) {
-			output.append(buffer, result);
-		}
-		// EOF
-		if (result == 0) {
-			break;
-		}
-		// Error
-		else if (result == -1) {
-			if (errno != EAGAIN && errno != EINTR) {
-				perror("\033[31;1mError:\033[0m read");
-				break;
-			}
-		}
-	}
-
-	close(fileDescriptor[ReadFileDescriptor]);
-}
-
-} // namespace Util

src/util/system.h

@@ -1,65 +0,0 @@
-#ifndef SYSTEM_H
-#define SYSTEM_H
-
-#include <cstdint>    // int32_t, uint32_t
-#include <functional> // function
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace Util {
-
-using LineCallback = std::function<void(std::vector<std::string>&)>;
-
-class System {
-public:
-	System();
-	virtual ~System() {}
-
-	enum FileDescriptor {
-		ReadFileDescriptor,
-		WriteFileDescriptor,
-	};
-
-	System operator()();
-	System operator()(const char* command);
-	System operator()(std::string command);
-	System operator()(std::string_view command);
-	System operator()(const std::vector<const char*>& arguments);
-	System operator()(const std::vector<std::string>& arguments);
-	System operator()(const std::vector<std::string_view>& arguments);
-
-	// Operator order
-	// + -> | -> && -> ||
-	System operator+(System rhs);
-	System operator|(System rhs);
-	System operator&&(System rhs);
-	System operator||(System rhs);
-
-	System& cut(uint32_t field, char delimiter = '\t');
-	System& sort(bool unique = false);
-	System& tail(int32_t number, bool starting = false);
-	System& apply(LineCallback callback);
-
-	void print(const std::vector<std::string>& arguments);
-
-	const std::vector<std::string>& arguments() const { return m_arguments; }
-	std::string output() const { return m_output; }
-	std::string error() const { return m_error; }
-	int status() const { return m_status; }
-
-private:
-	System(const std::vector<std::string>& arguments);
-
-	System exec(std::string input = "");
-	void readFromFileDescriptor(int fileDescriptor[2], std::string& output);
-
-	std::vector<std::string> m_arguments;
-	std::string m_output;
-	std::string m_error;
-	int m_status { 0 };
-};
-
-} // namespace Util
-
-#endif // SYSTEM_H

src/util/timer.cpp

@@ -1,88 +0,0 @@
-#include <chrono>  // high_resolution_clock, seconds, milliseconds, microseconds, nanoseconds
-#include <cstdint> // uint64_t
-#include <cstdio> // printf
-
-#include "util/timer.h"
-
-namespace Util {
-
-Timer::Timer()
-	: m_start(std::chrono::high_resolution_clock::now())
-{
-}
-
-Timer Timer::operator-(const Timer& timer)
-{
-	return Timer(TimePoint { m_start - timer.start() });
-}
-
-template<typename To, typename From>
-To Timer::to(From from)
-{
-	return std::chrono::duration_cast<To>(from);
-}
-
-uint64_t Timer::toSeconds()
-{
-	return to<std::chrono::seconds>(m_start.time_since_epoch()).count();
-}
-
-uint64_t Timer::toMilliseconds()
-{
-	return to<std::chrono::milliseconds>(m_start.time_since_epoch()).count();
-}
-
-uint64_t Timer::toMicroseconds()
-{
-	return to<std::chrono::microseconds>(m_start.time_since_epoch()).count();
-}
-
-uint64_t Timer::toNanoseconds()
-{
-	return to<std::chrono::nanoseconds>(m_start.time_since_epoch()).count();
-}
-
-template<typename T>
-uint64_t Timer::elapsed()
-{
-	auto now = std::chrono::high_resolution_clock::now();
-	return std::chrono::duration_cast<T>(now - m_start).count();
-}
-
-uint64_t Timer::elapsedSeconds()
-{
-	return elapsed<std::chrono::seconds>();
-}
-
-uint64_t Timer::elapsedMilliseconds()
-{
-	return elapsed<std::chrono::milliseconds>();
-}
-
-uint64_t Timer::elapsedMicroseconds()
-{
-	return elapsed<std::chrono::microseconds>();
-}
-
-uint64_t Timer::elapsedNanoseconds()
-{
-	return elapsed<std::chrono::nanoseconds>();
-}
-
-void Timer::fancyPrint(uint64_t nanoseconds)
-{
-	if (nanoseconds > 999999999) {
-		printf("%.3fs", nanoseconds / 1000000000.0);
-	}
-	else if (nanoseconds > 999999) {
-		printf("%.0fms", nanoseconds / 1000000.0);
-	}
-	else if (nanoseconds > 999) {
-		printf("%.0fμs", nanoseconds / 1000.0);
-	}
-	else {
-		printf("%luns", nanoseconds);
-	}
-}
-
-} // namespace Util

src/util/timer.h

@@ -1,45 +0,0 @@
-#ifndef TIMER_H
-#define TIMER_H
-
-#include <chrono>  // high_resolution_clock
-#include <cstdint> // uint64_t
-
-namespace Util {
-
-using TimePoint = std::chrono::high_resolution_clock::time_point;
-
-class Timer {
-public:
-	Timer();
-	Timer(const TimePoint& timePoint)
-		: m_start(timePoint)
-	{
-	}
-
-	Timer operator-(const Timer& timer);
-
-	template<typename To, typename From>
-	To to(From from);
-	uint64_t toSeconds();
-	uint64_t toMilliseconds();
-	uint64_t toMicroseconds();
-	uint64_t toNanoseconds();
-
-	template<typename T>
-	uint64_t elapsed();
-	uint64_t elapsedSeconds();
-	uint64_t elapsedMilliseconds();
-	uint64_t elapsedMicroseconds();
-	uint64_t elapsedNanoseconds();
-
-	static void fancyPrint(uint64_t nanoseconds);
-
-	const TimePoint& start() const { return m_start; }
-
-private:
-	TimePoint m_start;
-};
-
-} // namespace Util
-
-#endif // TIMER_H

test/macro.h

@@ -1,79 +0,0 @@
-#ifndef TEST_H
-#define TEST_H
-
-#include <cstdio>   // fprintf
-#include <iostream> // cerr
-
-#define GET_2TH_ARG(arg1, arg2, ...) arg2
-#define GET_3TH_ARG(arg1, arg2, arg3, ...) arg3
-#define GET_4TH_ARG(arg1, arg2, arg3, arg4, ...) arg4
-#define MACRO_CHOOSER_1(macro, ...) \
-	GET_2TH_ARG(__VA_ARGS__, macro##_1, )
-#define MACRO_CHOOSER_2(macro, ...) \
-	GET_3TH_ARG(__VA_ARGS__, macro##_2, macro##_1, )
-#define MACRO_CHOOSER_3(macro, ...) \
-	GET_4TH_ARG(__VA_ARGS__, macro##_3, macro##_2, macro##_1, )
-
-// -----------------------------------------
-
-#define EXPECT_IMPL(x, result)                                                 \
-	if (!(x)) {                                                                \
-		fprintf(stderr, " \033[31;1mFAIL:\033[0m  %s:%d: EXPECT(%s) failed\n", \
-		        __FILE__, __LINE__, #x);                                       \
-		Test::TestSuite::the().currentTestCaseFailed();                        \
-		result;                                                                \
-	}
-
-#define EXPECT_1(x) \
-	EXPECT_IMPL(x, (void)0)
-
-#define EXPECT_2(x, result) \
-	EXPECT_IMPL(x, result)
-
-#define EXPECT(...)                      \
-	MACRO_CHOOSER_2(EXPECT, __VA_ARGS__) \
-	(__VA_ARGS__)
-
-// -----------------------------------------
-
-#define EXPECT_EQ_IMPL(a, b, result)                                            \
-	if (a != b) {                                                               \
-		std::cerr << " \033[31;1mFAIL:\033[0m  " << __FILE__ << ":" << __LINE__ \
-				  << ": EXPECT_EQ(" << #a << ", " << #b ") failed with"         \
-				  << " lhs='" << a << "' and rhs='" << b << "'" << std::endl;   \
-		Test::TestSuite::the().currentTestCaseFailed();                         \
-		result;                                                                 \
-	}
-
-#define EXPECT_EQ_2(a, b) \
-	EXPECT_EQ_IMPL(a, b, (void)0)
-
-#define EXPECT_EQ_3(a, b, result) \
-	EXPECT_EQ_IMPL(a, b, result)
-
-#define EXPECT_EQ(...)                      \
-	MACRO_CHOOSER_3(EXPECT_EQ, __VA_ARGS__) \
-	(__VA_ARGS__)
-
-// -----------------------------------------
-
-#define EXPECT_NE_IMPL(a, b, result)                                            \
-	if (a == b) {                                                               \
-		std::cerr << " \033[31;1mFAIL:\033[0m  " << __FILE__ << ":" << __LINE__ \
-				  << ": EXPECT_NE(" << #a << ", " << #b ") failed with"         \
-				  << " lhs='" << a << "' and rhs='" << b << "'" << std::endl;   \
-		Test::TestSuite::the().currentTestCaseFailed();                         \
-		result;                                                                 \
-	}
-
-#define EXPECT_NE_2(a, b) \
-	EXPECT_NE_IMPL(a, b, (void)0)
-
-#define EXPECT_NE_3(a, b, result) \
-	EXPECT_NE_IMPL(a, b, result)
-
-#define EXPECT_NE(...)                      \
-	MACRO_CHOOSER_3(EXPECT_NE, __VA_ARGS__) \
-	(__VA_ARGS__)
-
-#endif // TEST_H

test/main.cpp

@@ -1,8 +0,0 @@
-#include "testsuite.h"
-
-int main(int, const char*[])
-{
-	Test::TestSuite::the().run();
-
-	return 0;
-}

test/testcase.h

@@ -1,45 +0,0 @@
-#ifndef TEST_CASE_H
-#define TEST_CASE_H
-
-#include <functional>
-#include <string>
-
-#define __TEST_CASE_FUNCTION(x) __test##x
-#define __TEST_CASE_STRUCT(x) __testStruct##x
-
-#define TEST_CASE(x)                                           \
-	static void __TEST_CASE_FUNCTION(x)();                     \
-	struct __TEST_CASE_STRUCT(x) {                             \
-		__TEST_CASE_STRUCT(x)                                  \
-		()                                                     \
-		{                                                      \
-			Test::TestSuite::the().addCase(                    \
-				{ #x, __TEST_CASE_FUNCTION(x) });              \
-		}                                                      \
-	};                                                         \
-	static struct __TEST_CASE_STRUCT(x) __TEST_CASE_STRUCT(x); \
-	static void __TEST_CASE_FUNCTION(x)()
-
-namespace Test {
-
-using TestFunction = std::function<void()>;
-
-class TestCase {
-public:
-	TestCase(const char* name, TestFunction&& function)
-		: m_name(name)
-		, m_function(function)
-	{
-	}
-
-	const char* name() const { return m_name; }
-	const TestFunction& function() const { return m_function; }
-
-private:
-	const char* m_name { nullptr };
-	TestFunction m_function;
-};
-
-} // namespace Test
-
-#endif // TEST_CASE_H

test/testsuite.cpp

@@ -1,76 +0,0 @@
-#include <cstddef> // size_t
-#include <cstdio>  // fclose, fopen, printf, stdout
-#include <string>
-#include <vector>
-
-#include "testsuite.h"
-#include "util/timer.h"
-
-namespace Test {
-
-TestSuite::TestSuite(s)
-{
-	m_outputStd = stdout;
-	m_outputErr = stderr;
-	m_outputNull = fopen("/dev/null", "w"); // Windows: nul
-}
-
-TestSuite::~TestSuite()
-{
-	fclose(m_outputNull);
-}
-
-void TestSuite::run()
-{
-	const char* escapePass = "\033[42;30;1m";
-	const char* escapeFail = "\033[41;1m";
-	const char* escapeGreen = "\033[32m";
-	const char* escapeGrey = "\033[37m";
-	const char* escapeRed = "\033[31m";
-	const char* escapeReset = "\033[0m";
-
-	printf("\n");
-	printf("---- Running %zu Test Cases ----\n", m_cases.size());
-
-	Util::Timer totalTimer;
-
-	size_t caseFailedCount = 0;
-	for (size_t i = 0; i < m_cases.size(); ++i) {
-
-		printf(" START  %s (%zu/%zu)\n", m_cases.at(i).name(), i + 1, m_cases.size());
-		m_currentTestCasePassed = true;
-
-		Util::Timer caseTimer;
-		m_cases.at(i).function()();
-		double elapsed = caseTimer.elapsedNanoseconds();
-
-		std::string state;
-		if (m_currentTestCasePassed) {
-			state.append(escapePass);
-			state.append(" PASS  ");
-			state.append(escapeReset);
-		}
-		else {
-			caseFailedCount++;
-			state.append(escapeFail);
-			state.append(" FAIL  ");
-			state.append(escapeReset);
-		}
-
-		printf("%s %s %s(", state.c_str(), m_cases.at(i).name(), escapeGrey);
-		Util::Timer::fancyPrint(elapsed);
-		printf(")%s\n", escapeReset);
-	}
-
-	printf("\n");
-	printf("Tests:  %s%zu failed%s, %s%zu passed%s, %zu total\n",
-	       escapeRed, caseFailedCount, escapeReset,
-	       escapeGreen, m_cases.size() - caseFailedCount, escapeReset,
-	       m_cases.size());
-
-	printf("Time:   ");
-	Util::Timer::fancyPrint(totalTimer.elapsedNanoseconds());
-	printf("\n");
-}
-
-} // namespace Test

test/testsuite.h

@@ -1,36 +0,0 @@
-#ifndef TEST_SUITE_H
-#define TEST_SUITE_H
-
-#include <cstdio> // FILE
-#include <vector>
-
-#include "testcase.h"
-#include "util/singleton.h"
-
-namespace Test {
-
-class TestSuite final : public Util::Singleton<TestSuite> {
-public:
-	TestSuite(s);
-	virtual ~TestSuite();
-
-	void run();
-	void addCase(const TestCase& testCase) { m_cases.push_back(testCase); }
-	void currentTestCaseFailed() { m_currentTestCasePassed = false; }
-
-	FILE* outputStd() const { return m_outputStd; }
-	FILE* outputErr() const { return m_outputErr; }
-	FILE* outputNull() const { return m_outputNull; }
-
-private:
-	bool m_currentTestCasePassed { true };
-	FILE* m_outputStd { nullptr };
-	FILE* m_outputErr { nullptr };
-	FILE* m_outputNull { nullptr };
-
-	std::vector<TestCase> m_cases;
-};
-
-} // namespace Test
-
-#endif // TEST_SUITE_H

test/unit/testdotfile.cpp

@@ -1,11 +1,10 @@
 /*
- * Copyright (C) 2022 Riyyi
+ * Copyright (C) 2022,2025 Riyyi
  *
  * SPDX-License-Identifier: MIT
  */
 
 #include <cstddef>    // size_t
-#include <cstdint>    // uint32_t
 #include <cstdio>     // stderr
 #include <filesystem> // path
 #include <string>
@@ -13,14 +12,14 @@
 #include <unordered_map>
 #include <vector>
 
+#include "ruc/file.h"
+
 #include "config.h"
 #include "dotfile.h"
 #include "machine.h"
 #include "macro.h"
 #include "testcase.h"
 #include "testsuite.h"
-#include "util/file.h"
-#include "util/system.h"
 
 const bool root = !geteuid() ? true : false;
 const std::filesystem::path homeDirectory = "/home/" + Machine::the().username();
@@ -28,7 +27,7 @@ const size_t homeDirectorySize = homeDirectory.string().size();
 
 void createTestDotfiles(const std::vector<std::string>& fileNames, const std::vector<std::string>& fileContents, bool asRoot = false)
 {
-	EXPECT(fileNames.size() == fileContents.size(), return );
+	EXPECT(fileNames.size() == fileContents.size(), return);
 
 	if (root && !asRoot) {
 		setegid(Machine::the().gid());
@@ -43,7 +42,7 @@ void createTestDotfiles(const std::vector<std::string>& fileNames, const std::ve
 			std::filesystem::create_directories(directory);
 		}
 
-		auto file = Util::File::create(fileName);
+		auto file = ruc::File::create(fileName);
 		if (file.data().size() == 0) {
 			file.append(fileContents.at(i).c_str()).flush();
 		}
@@ -374,8 +373,8 @@ TEST_CASE(AddDotfiles)
 		EXPECT(std::filesystem::exists(file), continue);
 		EXPECT(std::filesystem::exists(file.substr(homeDirectorySize + 1)), continue);
 
-		Util::File lhs(file);
+		ruc::File lhs(file);
-		Util::File rhs(file.substr(homeDirectorySize + 1));
+		ruc::File rhs(file.substr(homeDirectorySize + 1));
 		EXPECT_EQ(lhs.data(), rhs.data());
 	}
 
@@ -384,9 +383,9 @@ TEST_CASE(AddDotfiles)
 
 TEST_CASE(AddNonExistentDotfiles)
 {
-	stderr = Test::TestSuite::the().outputNull();
+	stderr = test::TestSuite::the().outputNull();
 	Dotfile::the().add({ homeDirectory / "__non-existent-test-file" });
-	stderr = Test::TestSuite::the().outputErr();
+	stderr = test::TestSuite::the().outputErr();
 
 	EXPECT(!std::filesystem::exists("__non-existent-test-file"));
 	removeTestDotfiles({ "__non-existent-test-file" });
@@ -430,8 +429,8 @@ TEST_CASE(PullDotfiles)
 		EXPECT(std::filesystem::exists(homeFileNames.at(i)), continue);
 		EXPECT(std::filesystem::exists(fileNames.at(i)), continue);
 
-		Util::File lhs(homeFileNames.at(i));
+		ruc::File lhs(homeFileNames.at(i));
-		Util::File rhs(fileNames.at(i));
+		ruc::File rhs(fileNames.at(i));
 		EXPECT_EQ(lhs.data(), rhs.data());
 	}
 
@@ -463,8 +462,8 @@ TEST_CASE(PushDotfiles)
 		EXPECT(std::filesystem::exists(file), continue);
 		EXPECT(std::filesystem::exists(homeDirectory / file), continue);
 
-		Util::File lhs(file);
+		ruc::File lhs(file);
-		Util::File rhs(homeDirectory / file);
+		ruc::File rhs((homeDirectory / file).string());
 		EXPECT_EQ(lhs.data(), rhs.data());
 	}
 
@@ -503,7 +502,7 @@ TEST_CASE(PushDotfilesWithIgnorePattern)
 TEST_CASE(PushDotfilesSelectivelyComment)
 {
 	std::vector<std::string> fileNames;
-	for (size_t i = 0; i < 36; ++i) {
+	for (size_t i = 0; i < 44; ++i) {
 		fileNames.push_back("__test-file-" + std::to_string(i + 1));
 	}
 
@@ -678,6 +677,43 @@ test data /**/ comment
 	  /*	  test data /**/ uncomment	  */
 	  /* <<< */
 )",
+
+		// Comment <!---->
+		"<!-- >>> distro=" + placeholder + " hostname=" + hostname + " user=" + username + " -->" + R"(
+test data <!----> comment
+<!-- <<< -->
+)",
+		"  <!-- >>> distro=" + distro + " hostname=" + placeholder + " user=" + username + " -->" + R"(
+  test data <!----> comment
+  <!-- <<< -->
+)",
+		"	<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + placeholder + " -->" + R"(
+	test data <!----> comment
+	<!-- <<< -->
+)",
+		"	  <!-- >>> distro=" + placeholder + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	  test data <!----> comment
+	  <!-- <<< -->
+)",
+
+		// Uncomment <!---->
+		"<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+<!-- test data <!----> uncomment -->
+<!-- <<< -->
+)",
+		"  <!-- >>> distro="
+			+ distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+  <!--  test data <!----> uncomment  -->
+  <!-- <<< -->
+)",
+		"	<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	<!--	test data <!----> uncomment	-->
+	<!-- <<< -->
+)",
+		"	  <!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	  <!--	  test data <!----> uncomment	  -->
+	  <!-- <<< -->
+)",
 	};
 
 	std::vector<std::string> pushedFileContents = {
@@ -846,6 +882,42 @@ test data /**/ uncomment
 	  test data /**/ uncomment
 	  /* <<< */
 )",
+
+		// Comment <!---->
+		"<!-- >>> distro=" + placeholder + " hostname=" + hostname + " user=" + username + " -->" + R"(
+<!-- test data <!----> comment -->
+<!-- <<< -->
+)",
+		"  <!-- >>> distro=" + distro + " hostname=" + placeholder + " user=" + username + " -->" + R"(
+  <!-- test data <!----> comment -->
+  <!-- <<< -->
+)",
+		"	<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + placeholder + " -->" + R"(
+	<!-- test data <!----> comment -->
+	<!-- <<< -->
+)",
+		"	  <!-- >>> distro=" + placeholder + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	  <!-- test data <!----> comment -->
+	  <!-- <<< -->
+)",
+
+		// Uncomment <!---->
+		"<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+test data <!----> uncomment
+<!-- <<< -->
+)",
+		"  <!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+  test data <!----> uncomment
+  <!-- <<< -->
+)",
+		"	<!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	test data <!----> uncomment
+	<!-- <<< -->
+)",
+		"	  <!-- >>> distro=" + distro + " hostname=" + hostname + " user=" + username + " -->" + R"(
+	  test data <!----> uncomment
+	  <!-- <<< -->
+)",
 	};
 
 	createTestDotfiles(fileNames, fileContents);
@@ -857,7 +929,7 @@ test data /**/ uncomment
 		EXPECT(std::filesystem::exists(file), continue);
 		EXPECT(std::filesystem::exists(homeDirectory / file), continue);
 
-		Util::File lhs(homeDirectory / file);
+		ruc::File lhs((homeDirectory / file).string());
 		EXPECT_EQ(lhs.data(), pushedFileContents.at(i));
 	}
 
@@ -866,7 +938,7 @@ test data /**/ uncomment
 
 TEST_CASE(AddSystemDotfiles)
 {
-	EXPECT(geteuid() == 0, return );
+	EXPECT(geteuid() == 0, return);
 
 	Config::the().setSystemPatterns({ "/etc/", "/usr/lib/" });
 	Dotfile::the().add({ "/etc/group", "/usr/lib/os-release" });
@@ -881,7 +953,7 @@ TEST_CASE(AddSystemDotfiles)
 
 TEST_CASE(PullSystemDotfiles)
 {
-	EXPECT(geteuid() == 0, return );
+	EXPECT(geteuid() == 0, return);
 
 	createTestDotfiles({ "etc/group" }, { "" }, true);
 
@@ -889,8 +961,8 @@ TEST_CASE(PullSystemDotfiles)
 	Dotfile::the().pull({ "etc/group" });
 	Config::the().setSystemPatterns({});
 
-	Util::File lhs("/etc/group");
+	ruc::File lhs("/etc/group");
-	Util::File rhs(Config::the().workingDirectory() / "etc/group");
+	ruc::File rhs((Config::the().workingDirectory() / "etc/group").string());
 	EXPECT_EQ(lhs.data(), rhs.data());
 
 	std::filesystem::remove_all(Config::the().workingDirectory() / "etc");
@@ -909,7 +981,7 @@ TEST_CASE(AddSymlinkDotfiles)
 
 	EXPECT(std::filesystem::is_symlink(symlinkFileName));
 	EXPECT_EQ(std::filesystem::read_symlink(symlinkFileName).string(), fileInHome);
-	EXPECT_EQ(Util::File(symlinkFileName).data(), "the file contents");
+	EXPECT_EQ(ruc::File(symlinkFileName.string()).data(), "the file contents");
 
 	removeTestDotfiles({ symlinkInHome, fileInHome });
 }
@@ -928,7 +1000,7 @@ TEST_CASE(PullSymlinkDotfiles)
 
 	EXPECT(std::filesystem::is_symlink(symlinkFileName));
 	EXPECT_EQ(std::filesystem::read_symlink(symlinkFileName).string(), fileInHome);
-	EXPECT_EQ(Util::File(symlinkFileName).data(), "the file contents");
+	EXPECT_EQ(ruc::File(symlinkFileName.string()).data(), "the file contents");
 
 	removeTestDotfiles({ symlinkInHome, fileInHome });
 }
@@ -946,7 +1018,7 @@ TEST_CASE(PushSymlinkDotfiles)
 
 	EXPECT(std::filesystem::is_symlink(symlinkInHome));
 	EXPECT_EQ(std::filesystem::read_symlink(symlinkInHome).string(), fileInHome);
-	EXPECT_EQ(Util::File(symlinkInHome).data(), "the file contents");
+	EXPECT_EQ(ruc::File(symlinkInHome.string()).data(), "the file contents");
 
 	removeTestDotfiles({ symlinkInHome, fileInHome });
 }

test/unit/testutilargparser.cpp

@@ -1,949 +0,0 @@
-#include <functional> // function
-#include <string>
-#include <vector>
-
-#include "macro.h"
-#include "testcase.h"
-#include "testsuite.h"
-#include "util/argparser.h"
-
-bool runParser(std::vector<const char*> arguments, std::function<void(Util::ArgParser&)> initializer = {})
-{
-	stdout = Test::TestSuite::the().outputNull();
-
-	Util::ArgParser parser;
-	if (initializer) {
-		initializer(parser);
-	}
-
-	arguments.insert(arguments.begin(), "app");
-	auto result = parser.parse(arguments.size(), arguments.data());
-
-	stdout = Test::TestSuite::the().outputStd();
-	return result;
-}
-
-// -----------------------------------------
-
-TEST_CASE(NoArguments)
-{
-	auto result = runParser({});
-	EXPECT_EQ(result, true);
-}
-
-// -----------------------------------------
-
-TEST_CASE(NonExistentArguments)
-{
-	auto result = runParser({ "-n", "-e" });
-	EXPECT_EQ(result, false);
-
-	result = runParser({ "--non", "--existent" });
-	EXPECT_EQ(result, false);
-
-	result = runParser({ "-n", "-e", "--non", "--existent" });
-	EXPECT_EQ(result, false);
-
-	result = runParser({ "no", "handling" });
-	EXPECT_EQ(result, false);
-}
-
-// -----------------------------------------
-
-TEST_CASE(RequiredStringArguments)
-{
-	// Single required string argument
-	std::string stringArg1 = "";
-	auto result = runParser({ "my-required-argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my-required-argument");
-
-	// Single required string argument, not given
-	stringArg1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringArg1, "");
-
-	// Multiple required string arguments
-	stringArg1 = "";
-	std::string stringArg2 = "";
-	std::string stringArg3 = "";
-	result = runParser({ "my", "required", "argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my");
-	EXPECT_EQ(stringArg2, "required");
-	EXPECT_EQ(stringArg3, "argument");
-
-	// Multiple required string arguments, not given
-	stringArg1 = "";
-	stringArg2 = "";
-	stringArg3 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringArg1, "");
-	EXPECT_EQ(stringArg2, "");
-	EXPECT_EQ(stringArg3, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(OptionalStringArguments)
-{
-	// Single optional string argument
-	std::string stringArg1 = "";
-	auto result = runParser({ "my-optional-argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my-optional-argument");
-
-	// Single optional string argument, not given
-	stringArg1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "");
-
-	// Multiple optional string arguments
-	stringArg1 = "";
-	std::string stringArg2 = "";
-	std::string stringArg3 = "";
-	result = runParser({ "my", "optional", "argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my");
-	EXPECT_EQ(stringArg2, "optional");
-	EXPECT_EQ(stringArg3, "argument");
-
-	// Multiple optional string arguments, not given
-	stringArg1 = "";
-	stringArg2 = "";
-	stringArg3 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "");
-	EXPECT_EQ(stringArg2, "");
-	EXPECT_EQ(stringArg3, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(NonRequiredStringArguments)
-{
-	// Single non-required string argument
-	std::string stringArg1 = "";
-	auto result = runParser({ "my-non-required-argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my-non-required-argument");
-
-	// Single non-required string argument, not given
-	stringArg1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "");
-
-	// Multiple non-required string arguments
-	stringArg1 = "";
-	std::string stringArg2 = "";
-	std::string stringArg3 = "";
-	result = runParser({ "my", "non-required", "argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "my");
-	EXPECT_EQ(stringArg2, "non-required");
-	EXPECT_EQ(stringArg3, "argument");
-
-	// Multiple non-required string arguments, not given
-	stringArg1 = "";
-	stringArg2 = "";
-	stringArg3 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringArg1, "");
-	EXPECT_EQ(stringArg2, "");
-	EXPECT_EQ(stringArg3, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(VectorStringArguments)
-{
-	// Required vector string argument, not given
-	std::vector<std::string> vectorArg1 = {};
-	auto result = runParser({}, [&](auto& parser) {
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(vectorArg1.size(), 0);
-
-	// Required vector string argument, one given
-	vectorArg1 = {};
-	result = runParser({ "foo" }, [&](auto& parser) {
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1[0], "foo");
-	}
-
-	// Required vector string argument, two given
-	vectorArg1 = {};
-	result = runParser({ "hello", "world" }, [&](auto& parser) {
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorArg1.size(), 2);
-	if (vectorArg1.size() == 2) {
-		EXPECT_EQ(vectorArg1[0], "hello");
-		EXPECT_EQ(vectorArg1[1], "world");
-	}
-}
-
-// -----------------------------------------
-
-TEST_CASE(CombinationOfNonRequiredArguments)
-{
-	// Optional arguments, one given
-	int intArg1 = 0;
-	double doubleArg1 = 0;
-	std::string stringArg1 = "";
-	auto result = runParser({ "optional argument" }, [&](auto& parser) {
-		parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(intArg1, 0);
-	EXPECT_EQ(doubleArg1, 0);
-	EXPECT_EQ(stringArg1, "optional argument");
-
-	// Optional arguments, two given
-	intArg1 = 0;
-	doubleArg1 = 0;
-	stringArg1 = "";
-	result = runParser({ "999.999", "optional argument" }, [&](auto& parser) {
-		parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(intArg1, 0);
-	EXPECT_EQ(doubleArg1, 999.999);
-	EXPECT_EQ(stringArg1, "optional argument");
-
-	// Optional arguments, two given, one valid
-	intArg1 = 0;
-	doubleArg1 = 0;
-	stringArg1 = "";
-	result = runParser({ "999,999", "optional argument" }, [&](auto& parser) {
-		parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(intArg1, 0);
-	EXPECT_EQ(doubleArg1, 0);
-	EXPECT_EQ(stringArg1, "999,999");
-
-	// Optional arguments, two given, both valid but wrong order
-	stringArg1 = "";
-	intArg1 = 0;
-	doubleArg1 = 0;
-	result = runParser({ "999.999", "optional argument" }, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringArg1, "999.999");
-	EXPECT_EQ(intArg1, 0);
-	EXPECT_EQ(doubleArg1, 0);
-}
-
-// -----------------------------------------
-
-TEST_CASE(BoolOptions)
-{
-	// Short option
-	bool boolOpt1 = false;
-	auto result = runParser({ "-b" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-
-	// Short option, not given
-	boolOpt1 = false;
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, false);
-
-	// Long option
-	boolOpt1 = false;
-	result = runParser({ "--bool" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, '\0', "bool", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-
-	// Long option, not given
-	boolOpt1 = false;
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(boolOpt1, '\0', "bool", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, false);
-
-	// Allow both short and long option, provide short
-	boolOpt1 = false;
-	result = runParser({ "-b" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', "bool", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-
-	// Allow both short and long option, provide long
-	boolOpt1 = false;
-	result = runParser({ "--bool" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', "bool", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-
-	// Allow both short and long option, provide both
-	boolOpt1 = false;
-	result = runParser({ "-b", "--bool" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', "bool", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-}
-
-// -----------------------------------------
-
-TEST_CASE(SingleRequiredStringOptions)
-{
-	// Single required string short option
-	std::string stringOpt1 = "";
-	auto result = runParser({ "-s", "my-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-required-argument");
-
-	// Single required string short option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "-smy-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-required-argument");
-
-	// Single required string short option, empty given
-	stringOpt1 = "";
-	result = runParser({ "-s" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single required string short option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single required string long option
-	stringOpt1 = "";
-	result = runParser({ "--string", "my-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-required-argument");
-
-	// Single required string long option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "--string=my-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-required-argument");
-
-	// Single required string long option, empty given
-	stringOpt1 = "";
-	result = runParser({ "--string" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single required string long option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(SingleOptionalStringOptions)
-{
-	// Single optional string short option
-	std::string stringOpt1 = "";
-	std::string stringArg1 = "";
-	auto result = runParser({ "-s", "my-optional-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-	EXPECT_EQ(stringArg1, "my-optional-argument");
-
-	// Single optional string short option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "-smy-optional-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-optional-argument");
-
-	// Single optional string short option, empty given
-	stringOpt1 = "";
-	result = runParser({ "-s" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single optional string short option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single optional string long option
-	stringOpt1 = "";
-	stringArg1 = "";
-	result = runParser({ "--string", "my-optional-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-	EXPECT_EQ(stringArg1, "my-optional-argument");
-
-	// Single optional string long option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "--string=my-optional-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "my-optional-argument");
-
-	// Single optional string long option, empty given
-	stringOpt1 = "";
-	result = runParser({ "--string" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single optional string long option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(SingleNonRequiredStringOptions)
-{
-	// Single non-required string short option
-	std::string stringOpt1 = "";
-	std::string stringArg1 = "";
-	auto result = runParser({ "-s", "my-non-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-	EXPECT_EQ(stringArg1, "my-non-required-argument");
-
-	// Single non-required string short option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "-smy-non-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single non-required string short option, empty given
-	stringOpt1 = "";
-	result = runParser({ "-s" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single non-required string short option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single non-required string long option
-	stringOpt1 = "";
-	stringArg1 = "";
-	result = runParser({ "--string", "my-non-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-	EXPECT_EQ(stringArg1, "my-non-required-argument");
-
-	// Single non-required string long option, given directly after
-	stringOpt1 = "";
-	result = runParser({ "--string=my-non-required-argument" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single non-required string long option, empty given
-	stringOpt1 = "";
-	result = runParser({ "--string" }, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-
-	// Single non-required string long option, not given
-	stringOpt1 = "";
-	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(stringOpt1, "");
-}
-
-// -----------------------------------------
-
-TEST_CASE(NumberOptions)
-{
-	// Required int short option
-	int intOpt1 = 0;
-	auto result = runParser({ "-i", "2147483647" }, [&](auto& parser) {
-		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(intOpt1, 2147483647);
-
-	// Required int short option, overflown value given
-	intOpt1 = 0;
-	result = runParser({ "-i", "2147483648" }, [&](auto& parser) {
-		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(intOpt1, 0);
-
-	// Required int short option, empty given
-	intOpt1 = 0;
-	result = runParser({ "-i" }, [&](auto& parser) {
-		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(intOpt1, 0);
-
-	// Required unsigned int short option
-	unsigned int unsignedIntOpt1 = 0;
-	result = runParser({ "-u", "4294967295" }, [&](auto& parser) {
-		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(unsignedIntOpt1, 4294967295);
-
-	// Required unsigned int short option, overflown value given
-	unsignedIntOpt1 = 0;
-	result = runParser({ "-u", "4294967296" }, [&](auto& parser) {
-		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(unsignedIntOpt1, 0);
-
-	// Required unsigned int short option, empty given
-	unsignedIntOpt1 = 0;
-	result = runParser({ "-u" }, [&](auto& parser) {
-		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(unsignedIntOpt1, 0);
-
-	// Required double short option
-	double doubleOpt1 = 0;
-	result = runParser({ "-d", "999.999" }, [&](auto& parser) {
-		parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(doubleOpt1, 999.999);
-
-	// Required double short option, empty given
-	doubleOpt1 = 0;
-	result = runParser({ "-d" }, [&](auto& parser) {
-		parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(doubleOpt1, 0);
-}
-
-// -----------------------------------------
-
-TEST_CASE(VectorStringOptions)
-{
-	// Required vector string short option, not given
-	std::vector<std::string> vectorOpt1 = {};
-	auto result = runParser({}, [&](auto& parser) {
-		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 0);
-
-	// Required vector string short option, empty given
-	vectorOpt1 = {};
-	result = runParser({ "-v" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(vectorOpt1.size(), 0);
-
-	// Required vector string short option, one given
-	vectorOpt1 = {};
-	result = runParser({ "-v", "a vector argument!" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 1);
-	if (vectorOpt1.size() == 1) {
-		EXPECT_EQ(vectorOpt1[0], "a vector argument!");
-	}
-
-	// Required vector string short option, two given
-	vectorOpt1 = {};
-	result = runParser({ "-v", "hello", "-v", "world" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 2);
-	if (vectorOpt1.size() == 2) {
-		EXPECT_EQ(vectorOpt1[0], "hello");
-		EXPECT_EQ(vectorOpt1[1], "world");
-	}
-
-	// Required vector string short option, two given directly after
-	vectorOpt1 = {};
-	result = runParser({ "-vhello", "-vworld" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 2);
-	if (vectorOpt1.size() == 2) {
-		EXPECT_EQ(vectorOpt1[0], "hello");
-		EXPECT_EQ(vectorOpt1[1], "world");
-	}
-
-	// Required vector string long option, empty given
-	vectorOpt1 = {};
-	result = runParser({ "--vector" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(vectorOpt1.size(), 0);
-
-	// Required vector string long option, one given
-	vectorOpt1 = {};
-	result = runParser({ "--vector", "a vector argument!" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 1);
-	if (vectorOpt1.size() == 1) {
-		EXPECT_EQ(vectorOpt1[0], "a vector argument!");
-	}
-
-	// Required vector string long option, two given
-	vectorOpt1 = {};
-	result = runParser({ "--vector", "hello", "--vector", "world" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 2);
-	if (vectorOpt1.size() == 2) {
-		EXPECT_EQ(vectorOpt1[0], "hello");
-		EXPECT_EQ(vectorOpt1[1], "world");
-	}
-
-	// Required vector string long option, two given directly after
-	vectorOpt1 = {};
-	result = runParser({ "--vector=hello", "--vector=world" }, [&](auto& parser) {
-		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(vectorOpt1.size(), 2);
-	if (vectorOpt1.size() == 2) {
-		EXPECT_EQ(vectorOpt1.at(0), "hello");
-		EXPECT_EQ(vectorOpt1.at(1), "world");
-	}
-}
-
-// -----------------------------------------
-
-TEST_CASE(MultipleOptions)
-{
-	// Both short options, second is required, with a non-option parameter in-between
-	bool boolOpt1 = false;
-	std::string stringOpt1 = "";
-	std::vector<std::string> vectorArg1 = {};
-	auto result = runParser({ "-b", "something", "-s", "a-string-value" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(stringOpt1, "a-string-value");
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "something");
-	}
-}
-
-// -----------------------------------------
-
-TEST_CASE(StopOnDoubleDashOption)
-{
-	// Bool short options, missing
-	// Expected: The bool options are interpreted as non-option parameters
-	bool boolOpt1 = false;
-	bool boolOpt2 = false;
-	std::vector<std::string> vectorArg1 = {};
-	auto result = runParser({ "--", "-b", "-c" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, false);
-	EXPECT_EQ(boolOpt2, false);
-	EXPECT_EQ(vectorArg1.size(), 2);
-	if (vectorArg1.size() == 2) {
-		EXPECT_EQ(vectorArg1.at(0), "-b");
-		EXPECT_EQ(vectorArg1.at(1), "-c");
-	}
-
-	// Bool short options, one given
-	// Expected: boolOpt1 is set, one non-option parameter
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "-b", "--", "-c" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, false);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "-c");
-	}
-
-	// Bool long options, missing
-	// Expected: The bool options are interpreted as non-option parameters
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "--", "--bool", "--cool" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, '\0', "bool", nullptr, nullptr);
-		parser.addOption(boolOpt2, '\0', "cool", nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, false);
-	EXPECT_EQ(boolOpt2, false);
-	EXPECT_EQ(vectorArg1.size(), 2);
-	if (vectorArg1.size() == 2) {
-		EXPECT_EQ(vectorArg1.at(0), "--bool");
-		EXPECT_EQ(vectorArg1.at(1), "--cool");
-	}
-
-	// Bool long options, one given
-	// Expected: boolOpt1 is set, one non-option parameter
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "--bool", "--", "--cool" }, [&](auto& parser) {
-		parser.addOption(boolOpt1, '\0', "bool", nullptr, nullptr);
-		parser.addOption(boolOpt2, '\0', "cool", nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, false);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "--cool");
-	}
-}
-
-// -----------------------------------------
-
-TEST_CASE(StopOnFirstNonOption)
-{
-	// Do not stop on first non-option; arguments are in correct order
-	// Expected: The bool options are set and one non-option parameter
-	bool boolOpt1 = false;
-	bool boolOpt2 = false;
-	std::vector<std::string> vectorArg1 = {};
-	auto result = runParser({ "-b", "-c", "stopping" }, [&](auto& parser) {
-		parser.setStopParsingOnFirstNonOption(false);
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, true);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "stopping");
-	}
-
-	// Do not stop on first non-option; arguments are in wrong order
-	// Expected: The bool options are set and one non-option parameter
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "-b", "stopping", "-c" }, [&](auto& parser) {
-		parser.setStopParsingOnFirstNonOption(false);
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, true);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "stopping");
-	}
-
-	// Stop on first non option, arguments are in correct order
-	// Expected: The bool options are set and one non-option parameter
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "-b", "-c", "stopping" }, [&](auto& parser) {
-		parser.setStopParsingOnFirstNonOption(true);
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, true);
-	EXPECT_EQ(vectorArg1.size(), 1);
-	if (vectorArg1.size() == 1) {
-		EXPECT_EQ(vectorArg1.at(0), "stopping");
-	}
-
-	// Stop on first non option, arguments are in wrong order
-	// Expected: boolOpt1 is set and the rest are non-option parameters
-	boolOpt1 = false;
-	boolOpt2 = false;
-	vectorArg1 = {};
-	result = runParser({ "-b", "stopping", "-c" }, [&](auto& parser) {
-		parser.setStopParsingOnFirstNonOption(true);
-		parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
-		parser.addOption(boolOpt2, 'c', nullptr, nullptr, nullptr);
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
-	});
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(boolOpt1, true);
-	EXPECT_EQ(boolOpt2, false);
-	EXPECT_EQ(vectorArg1.size(), 2);
-	if (vectorArg1.size() == 2) {
-		EXPECT_EQ(vectorArg1.at(0), "stopping");
-		EXPECT_EQ(vectorArg1.at(1), "-c");
-	}
-}
-
-// -----------------------------------------
-
-TEST_CASE(ExitOnFirstError)
-{
-	// Do not stop on first error, one non-existing given
-	// Expected: parsing fails, boolOpt1 is set
-	bool boolOpt1 = false;
-	auto result = runParser({ "--this-doesnt-exist", "--this-exist" }, [&](auto& parser) {
-		parser.setExitOnFirstError(false);
-		parser.addOption(boolOpt1, '\0', "this-exist", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(boolOpt1, true);
-
-	// Stop on first error, one non-existing given
-	// Expected: parsing fails, boolOpt1 is not set
-	boolOpt1 = false;
-	result = runParser({ "--this-doesnt-exist", "--this-exist" }, [&](auto& parser) {
-		parser.setExitOnFirstError(true);
-		parser.addOption(boolOpt1, '\0', "this-exist", nullptr, nullptr);
-	});
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(boolOpt1, false);
-}

test/unit/testutiljson.cpp

@@ -1,570 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#include <cstddef>    // nullptr_t
-#include <cstdint>    // uint32_t
-#include <functional> // function
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "macro.h"
-#include "testcase.h"
-#include "testsuite.h"
-#include "util/json/array.h"
-#include "util/json/job.h"
-#include "util/json/lexer.h"
-#include "util/json/parser.h"
-#include "util/json/serializer.h"
-#include "util/json/value.h"
-
-#define DONT_PRINT_PARSER_ERRORS
-
-#ifndef DONT_PRINT_PARSER_ERRORS
-#define EXEC(x) x
-#else
-#define EXEC(x)                                   \
-	stderr = Test::TestSuite::the().outputNull(); \
-	x;                                            \
-	stderr = Test::TestSuite::the().outputErr();
-#endif
-
-std::vector<Json::Token> lex(const std::string& input)
-{
-	EXEC(
-		Json::Job job(input);
-		Json::Lexer lexer(&job);
-		lexer.analyze(););
-	return *job.tokens();
-}
-
-Json::Value parse(const std::string& input)
-{
-	EXEC(
-		Json::Job job(input);
-		Json::Lexer lexer(&job);
-		lexer.analyze(););
-
-	if (!job.success()) {
-		return nullptr;
-	}
-
-	EXEC(
-		Json::Parser parser(&job);
-		Json::Value json = parser.parse(););
-
-	if (!job.success()) {
-		return nullptr;
-	}
-
-	return json;
-}
-
-std::string serialize(const std::string& input, uint32_t indent = 0)
-{
-	EXEC(
-		auto json = Json::Value::parse(input););
-	return json.dump(indent);
-}
-
-// -----------------------------------------
-
-TEST_CASE(JsonLexer)
-{
-	std::vector<Json::Token> tokens;
-
-	// Literal
-
-	tokens = lex("true");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "true");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
-
-	tokens = lex("false");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "false");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
-
-	tokens = lex("null");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "null");
-	EXPECT(tokens[0].type == Json::Token::Type::Literal);
-
-	// Number
-
-	tokens = lex("3.14");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "3.14");
-	EXPECT(tokens[0].type == Json::Token::Type::Number);
-
-	tokens = lex("-3.14e+2");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "-3.14e+2");
-	EXPECT(tokens[0].type == Json::Token::Type::Number);
-
-	tokens = lex("+3.14");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "+");
-	EXPECT(tokens[0].type == Json::Token::Type::None);
-
-	// String
-
-	tokens = lex(R"("a string")");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "a string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
-
-	tokens = lex(R"("a string""another string")");
-	EXPECT_EQ(tokens.size(), 2);
-	EXPECT_EQ(tokens[0].symbol, "a string");
-	EXPECT_EQ(tokens[1].symbol, "another string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
-
-	tokens = lex("\"a string\nwill break on the newline symbol\"");
-	EXPECT_EQ(tokens.size(), 1);
-	EXPECT_EQ(tokens[0].symbol, "a string");
-	EXPECT(tokens[0].type == Json::Token::Type::String);
-
-	// Array
-
-	tokens = lex("[]");
-	EXPECT_EQ(tokens.size(), 2);
-	EXPECT_EQ(tokens[0].symbol, "[");
-	EXPECT_EQ(tokens[1].symbol, "]");
-
-	tokens = lex("[\n\n\n]");
-	EXPECT_EQ(tokens.size(), 2);
-	EXPECT_EQ(tokens[0].symbol, "[");
-	EXPECT_EQ(tokens[1].symbol, "]");
-
-	// Object
-
-	tokens = lex("{}");
-	EXPECT_EQ(tokens.size(), 2);
-	EXPECT_EQ(tokens[0].symbol, "{");
-	EXPECT_EQ(tokens[1].symbol, "}");
-
-	tokens = lex("{\n\n\n}");
-	EXPECT_EQ(tokens.size(), 2);
-	EXPECT_EQ(tokens[0].symbol, "{");
-	EXPECT_EQ(tokens[1].symbol, "}");
-}
-
-TEST_CASE(JsonParser)
-{
-	Json::Value json;
-
-	json = parse("null");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("true");
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
-
-	json = parse("false");
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
-
-	json = parse("3.14");
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
-
-	json = parse(R"("a string")");
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
-
-	// Array
-
-	json = parse("[");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("[ 123");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("[ 123,");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("[ 123, ]");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("[ 123 456 ]");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("[]");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
-
-	json = parse(R"([ "element", 3.14 ])");
-	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
-
-	// Object
-
-	json = parse("{");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name")");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name":)");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name":,)");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name":"value")");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name":"value",)");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name":"value", })");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ "name" "value" })");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse(R"({ 123 })");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("{}");
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
-
-	json = parse(R"({ "name": "value", "name2": 3.14 })");
-	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
-
-	// Multiple root elements
-
-	json = parse("54 false");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("3.14, 666");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = parse("true\nfalse");
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-}
-
-TEST_CASE(JsonToJsonValue)
-{
-	Json::Value json;
-
-	json = {};
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = nullptr;
-	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Json::Value::Type::Null);
-
-	json = true;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
-
-	json = false;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Bool);
-
-	json = 666;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
-
-	json = 3.14;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::Number);
-
-	const char* characters = "my string";
-	json = characters;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
-
-	std::string string = "my string";
-	json = string;
-	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Json::Value::Type::String);
-
-	// Nested Array with multiple types
-	json = { "element", 3.14, true, nullptr, { "nested element", { "more nesting", { 1, 2, 3, "yes" } } } };
-	EXPECT_EQ(json.size(), 5);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
-
-	// Nested Object with multiple types
-	json = { { "name", "value" }, { "name2", 3.14 }, { "name3", true }, { "name4", nullptr }, { "name5", { { "nested name", "value" } } } };
-	EXPECT_EQ(json.size(), 5);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
-
-	// Array with singular type
-	std::vector<std::string> vector = { "element", "element2", "element3" };
-	json = vector;
-	EXPECT_EQ(json.size(), 3);
-	EXPECT_EQ(json.type(), Json::Value::Type::Array);
-
-	// Object with singular type
-	std::map<std::string, std::string> map = { { "name", "value" }, { "name2", "value2" } };
-	json = map;
-	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
-
-	// Object with singular type
-	std::unordered_map<std::string, std::string> unorderedMap = { { "name", "value" }, { "name2", "value2" } };
-	json = unorderedMap;
-	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Json::Value::Type::Object);
-}
-
-TEST_CASE(JsonFromJsonValue)
-{
-	Json::Value json;
-
-	json = nullptr;
-	EXPECT_EQ(json.get<std::nullptr_t>(), nullptr);
-
-	json = true;
-	EXPECT_EQ(json.get<bool>(), true);
-
-	json = false;
-	EXPECT_EQ(json.get<bool>(), false);
-
-	json = 666;
-	EXPECT_EQ(json.get<int>(), 666);
-
-	json = 3.14;
-	EXPECT_EQ(json.get<double>(), 3.14);
-
-	std::string string;
-	json = "my string";
-	json.getTo(string);
-	EXPECT_EQ(string, "my string");
-	EXPECT_EQ(json.get<std::string>(), "my string");
-
-	// Array with singular type
-	json = { "element", "element2" };
-	EXPECT_EQ(json[0].get<std::string>(), "element");
-	EXPECT_EQ(json.at(1).get<std::string>(), "element2");
-	auto array = json.get<std::vector<std::string>>();
-	EXPECT_EQ(array.size(), 2);
-	EXPECT_EQ(array[0], "element");
-	EXPECT_EQ(array[1], "element2");
-
-	// Array with multiple types
-	json = { "string", 3.14, true, nullptr };
-	EXPECT_EQ(json[0].get<std::string>(), "string");
-	EXPECT_EQ(json.at(1).get<double>(), 3.14);
-	EXPECT_EQ(json[2].get<bool>(), true);
-	EXPECT_EQ(json[3].get<std::nullptr_t>(), nullptr);
-	auto valueArray = json.get<std::vector<Json::Value>>();
-	EXPECT_EQ(valueArray.size(), 4);
-	EXPECT_EQ(valueArray[0].get<std::string>(), "string");
-	EXPECT_EQ(valueArray[1].get<double>(), 3.14);
-	EXPECT_EQ(valueArray[2].get<bool>(), true);
-	EXPECT_EQ(valueArray[3].get<std::nullptr_t>(), nullptr);
-
-	// Nested Array with multiple types
-	json = {
-		"value",
-		{
-			"thing",
-			666,
-		},
-		{
-			{
-				3.14,
-			},
-		}
-	};
-	EXPECT_EQ(json[0].get<std::string>(), "value");
-	EXPECT_EQ(json.at(1)[0].get<std::string>(), "thing");
-	EXPECT_EQ(json[1].at(1).get<int>(), 666);
-	EXPECT_EQ(json[2][0][0].get<double>(), 3.14);
-
-	// Object with singular type
-	json = { { "name", "value" }, { "name2", "value2" } };
-	EXPECT_EQ(json["name"].get<std::string>(), "value");
-	EXPECT_EQ(json.at("name2").get<std::string>(), "value2");
-	auto object = json.get<std::map<std::string, std::string>>();
-	EXPECT_EQ(object.size(), 2);
-	EXPECT_EQ(object["name"], "value");
-	EXPECT_EQ(object["name2"], "value2");
-	auto unorderedObject = json.get<std::unordered_map<std::string, std::string>>();
-	EXPECT_EQ(unorderedObject.size(), 2);
-	EXPECT_EQ(unorderedObject["name"], "value");
-	EXPECT_EQ(unorderedObject["name2"], "value2");
-
-	// Object with multiple types
-	json = { { "name", "value" }, { "name2", 3.14 }, { "name3", true }, { "name4", nullptr } };
-	EXPECT_EQ(json["name"].get<std::string>(), "value");
-	EXPECT_EQ(json.at("name2").get<double>(), 3.14);
-	EXPECT_EQ(json["name3"].get<bool>(), true);
-	EXPECT_EQ(json["name4"].get<std::nullptr_t>(), nullptr);
-	auto valueObject = json.get<std::map<std::string, Json::Value>>();
-	EXPECT_EQ(valueObject.size(), 4);
-	EXPECT_EQ(valueObject["name"].get<std::string>(), "value");
-	EXPECT_EQ(valueObject["name2"].get<double>(), 3.14);
-	EXPECT_EQ(valueObject["name3"].get<bool>(), true);
-	EXPECT_EQ(valueObject["name4"].get<std::nullptr_t>(), nullptr);
-
-	// Nested Object with multiple types
-	json = {
-		{
-			"name",
-			"value",
-		},
-		{
-			"nest 1-deep",
-			{ {
-				"number",
-				1,
-			} },
-		},
-		{
-			"nest 2-deep",
-			{ {
-				"nest 1-deep",
-				{ {
-					"bool",
-					true,
-				} },
-			} },
-		},
-	};
-	EXPECT_EQ(json["name"].get<std::string>(), "value");
-	EXPECT_EQ(json["nest 1-deep"]["number"].get<int>(), 1);
-	EXPECT_EQ(json["nest 2-deep"]["nest 1-deep"]["bool"].get<bool>(), true);
-}
-
-TEST_CASE(JsonImplicitConversion)
-{
-	Json::Value array;
-	array[0];
-	EXPECT_EQ(array.type(), Json::Value::Type::Array);
-
-	Json::Value arrayEmplace;
-	arrayEmplace.emplace_back("element");
-	arrayEmplace.emplace_back({ "nested element" });
-	EXPECT_EQ(arrayEmplace.type(), Json::Value::Type::Array);
-	EXPECT_EQ(arrayEmplace[1].type(), Json::Value::Type::Array);
-
-	Json::Value object;
-	object[""];
-	EXPECT_EQ(object.type(), Json::Value::Type::Object);
-
-	Json::Value objectEmplace;
-	objectEmplace.emplace("name", "value");
-	objectEmplace.emplace("name2", { { "nested name", "value" } });
-	EXPECT_EQ(objectEmplace.type(), Json::Value::Type::Object);
-	EXPECT_EQ(objectEmplace["name2"].type(), Json::Value::Type::Object);
-}
-
-TEST_CASE(JsonSerializer)
-{
-	EXPECT_EQ(serialize(""), "null");
-	EXPECT_EQ(serialize("null"), "null");
-	EXPECT_EQ(serialize("true"), "true");
-	EXPECT_EQ(serialize("false"), "false");
-	EXPECT_EQ(serialize("3.14"), "3.14");
-	EXPECT_EQ(serialize(R"("string")"), R"("string")");
-
-	EXPECT_EQ(serialize("\n\n\n"), "null");
-	EXPECT_EQ(serialize("null\n"), "null");
-	EXPECT_EQ(serialize("true\n"), "true");
-	EXPECT_EQ(serialize("false\n"), "false");
-	EXPECT_EQ(serialize("3.14\n"), "3.14");
-	// clang-format off
-	EXPECT_EQ(serialize(R"("string")" "\n"), R"("string")");
-	// clang-format on
-
-	EXPECT_EQ(serialize("[\n\n\n]"), "[]");
-	EXPECT_EQ(serialize("[null]"), "[null]");
-	EXPECT_EQ(serialize("[true]"), "[true]");
-	EXPECT_EQ(serialize("[false]"), "[false]");
-	EXPECT_EQ(serialize("[3.14]"), "[3.14]");
-	EXPECT_EQ(serialize(R"(["string"])"), R"(["string"])");
-
-	EXPECT_EQ(serialize("[\n\n\n]", 4), "[\n]");
-	EXPECT_EQ(serialize("[null]", 4), "[\n    null\n]");
-	EXPECT_EQ(serialize("[true]", 4), "[\n    true\n]");
-	EXPECT_EQ(serialize("[false]", 4), "[\n    false\n]");
-	EXPECT_EQ(serialize("[3.14]", 4), "[\n    3.14\n]");
-	// clang-format off
-	EXPECT_EQ(serialize(R"(["string"])", 4), "[\n    " R"("string")" "\n]");
-	// clang-format on
-
-	// Check for trailing comma on last array element
-	EXPECT_EQ(serialize(R"([1])"), R"([1])");
-	EXPECT_EQ(serialize(R"([1,2])"), R"([1,2])");
-	EXPECT_EQ(serialize(R"([1,2,3])"), R"([1,2,3])");
-
-	// Check for trailing comma on last object member
-	EXPECT_EQ(serialize(R"({"n1":"v1"})"), R"({"n1":"v1"})");
-	EXPECT_EQ(serialize(R"({"n1":"v1", "n2":"v2"})"), R"({"n1":"v1","n2":"v2"})");
-	EXPECT_EQ(serialize(R"({"n1":"v1", "n2":"v2", "n3":"v3"})"), R"({"n1":"v1","n2":"v2","n3":"v3"})");
-
-	// clang-format off
-	EXPECT_EQ(serialize(R"({
-	"object member one": [
-		"array element one"
-	],
-	"object member two": [
-		"array element one",
-		"array element two"
-	],
-	"object member three": [
-		"array element one",
-		2,
-		3.0,
-		4.56,
-		true,
-		false,
-		null
-	],
-	"object member four": 3.14,
-	"object member five": "value five",
-	"object member six": null,
-	"object member seven": { "no": 0 }
-})", 4), R"({
-    "object member five": "value five",
-    "object member four": 3.14,
-    "object member one": [
-        "array element one"
-    ],
-    "object member seven": {
-        "no": 0
-    },
-    "object member six": null,
-    "object member three": [
-        "array element one",
-        2,
-        3,
-        4.56,
-        true,
-        false,
-        null
-    ],
-    "object member two": [
-        "array element one",
-        "array element two"
-    ]
-})");
-	// clang-format on
-}

test/unit/testutilshell.cpp

@@ -1,39 +0,0 @@
-#include <string>
-
-#include "macro.h"
-#include "testcase.h"
-#include "testsuite.h"
-#include "util/shell.h"
-
-bool runShell(const char* command, std::string* output = nullptr)
-{
-	stdout = Test::TestSuite::the().outputNull();
-
-	Util::Shell $;
-	auto exec = $(command);
-	if (output) {
-		*output = exec.output();
-	}
-
-	stdout = Test::TestSuite::the().outputStd();
-	return !exec.status() ? true : false;
-}
-
-// -----------------------------------------
-
-TEST_CASE(ShellCommand)
-{
-	// Pipe test, grep section of the echo command, return true
-	std::string output = "";
-	auto result = runShell("echo 'Hello World!' | grep --only-matching 'Hello'", &output);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello\n");
-
-	// Return false
-	result = runShell("exit 1");
-	EXPECT_EQ(result, false);
-
-	// Return false
-	result = runShell("failure() { return 1; }; failure");
-	EXPECT_EQ(result, false);
-}

test/unit/testutilsystem.cpp

@@ -1,98 +0,0 @@
-#include <functional> // function
-#include <string>
-#include <vector>
-
-#include "macro.h"
-#include "testcase.h"
-#include "testsuite.h"
-#include "util/system.h"
-
-bool runSystem(std::function<Util::System(Util::System&)> commands, std::string* output = nullptr, std::string* error = nullptr)
-{
-	Util::System system;
-	auto exec = commands(system);
-	if (output) {
-		*output = exec.output();
-	}
-	if (error) {
-		*error = exec.error();
-	}
-
-	return !exec.status() ? true : false;
-}
-
-// -----------------------------------------
-
-TEST_CASE(SystemCommand)
-{
-	// Regular echo command, return true
-	std::string output = "";
-	std::string error = "";
-	auto result = runSystem([&](auto& $) {
-		return $("echo Hello World!")();
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello World!\n");
-	EXPECT_EQ(error, "");
-
-	// Apend output of two echo commands, return true
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return $("echo -n Hello ") + $("echo -n World!");
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello World!");
-	EXPECT_EQ(error, "");
-
-	// Pipe test, grep section of the echo command, return true
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return $("echo Hello World!") | $("grep --only-matching Hello");
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello\n");
-	EXPECT_EQ(error, "");
-
-	// Run all commands until first false, return true
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return $("echo Hello") && $("echo World!");
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello\nWorld!\n");
-	EXPECT_EQ(error, "");
-
-	// Run all commands until first true, return true
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return $("echo Hello") || $("echo World!");
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "Hello\n");
-	EXPECT_EQ(error, "");
-
-	// And plus pipe test, grep the middle word, return true
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return ($("echo -n one ") && $("echo -n two ") && $("echo -n three")) | $("grep --only-matching two");
-	}, &output, &error);
-	EXPECT_EQ(result, true);
-	EXPECT_EQ(output, "two\n");
-	EXPECT_EQ(error, "");
-
-	// FIXME waitpid does not seem to get the right exit status here
-	// Return false
-	output = "";
-	error = "";
-	result = runSystem([&](auto& $) {
-		return $("exit 1")();
-	}, &output, &error);
-	EXPECT_EQ(result, false);
-	EXPECT_EQ(output, "");
-	EXPECT_EQ(error, "");
-}