Everywhere: Move everything in namescape Util => ruc

CMakeLists.txt

@@ -63,7 +63,7 @@ target_include_directories(${PROJECT} PRIVATE
 # Unit test library target
 
 # Define source files
-file(GLOB TEST_LIBRARY_SOURCES "test/*.cpp" "src/util/timer.cpp")
+file(GLOB TEST_LIBRARY_SOURCES "test/*.cpp" "src/ruc/timer.cpp")
 
 add_library(${PROJECT}-test STATIC ${TEST_LIBRARY_SOURCES})
 target_include_directories(${PROJECT}-test PRIVATE

src/ruc/argparser.cpp

@@ -14,9 +14,9 @@
 #include <string_view>
 #include <vector>
 
-#include "util/argparser.h"
+#include "ruc/argparser.h"
 
-namespace Util {
+namespace ruc {
 
 ArgParser::ArgParser()
 {
@@ -565,4 +565,4 @@ AcceptFunction ArgParser::getAcceptFunction(std::vector<std::string>& value)
 	};
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/argparser.h

@@ -13,7 +13,7 @@
 #include <string_view>
 #include <vector>
 
-namespace Util {
+namespace ruc {
 
 using AcceptFunction = std::function<bool(const char*)>;
 
@@ -117,4 +117,4 @@ private:
 	std::vector<Argument> m_arguments;
 };
 
-} // namespace Util
+} // namespace ruc

src/ruc/file.cpp

@@ -10,10 +10,10 @@
 #include <memory>  // make_unique
 #include <string>
 
-#include "util/file.h"
-#include "util/meta/assert.h"
+#include "ruc/file.h"
+#include "ruc/meta/assert.h"
 
-namespace Util {
+namespace ruc {
 
 File::File(const std::string& path)
 	: m_path(path)
@@ -50,7 +50,7 @@ File File::create(const std::string& path)
 		std::ofstream { path };
 	}
 
-	return Util::File(path);
+	return File(path);
 }
 
 // -----------------------------------------
@@ -86,4 +86,4 @@ File& File::flush()
 	return *this;
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/file.h

@@ -8,7 +8,7 @@
 
 #include <string>
 
-namespace Util {
+namespace ruc {
 
 class File {
 public:
@@ -31,4 +31,4 @@ private:
 	std::string m_data;
 };
 
-} // namespace Util
+} // namespace ruc

src/ruc/format/builder.cpp

@@ -14,11 +14,11 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/builder.h"
-#include "util/format/parser.h"
-#include "util/meta/assert.h"
+#include "ruc/format/builder.h"
+#include "ruc/format/parser.h"
+#include "ruc/meta/assert.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 void Builder::putLiteral(std::string_view literal)
 {
@@ -219,4 +219,4 @@ void Builder::putString(std::string_view string, char fill, Align align, size_t
 	};
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/builder.h

@@ -11,7 +11,7 @@
 #include <sstream> // stringstream
 #include <string_view>
 
-namespace Util::Format {
+namespace ruc::format {
 
 class Builder {
 public:
@@ -68,7 +68,7 @@ private:
 	std::stringstream& m_builder;
 };
 
-} // namespace Util::Format
+} // namespace ruc::format
 
 #if 0
 	// Defaults based on type

src/ruc/format/color.cpp

@@ -10,11 +10,11 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/color.h"
-#include "util/format/format.h"
-#include "util/meta/assert.h"
+#include "ruc/format/color.h"
+#include "ruc/format/format.h"
+#include "ruc/meta/assert.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 TextStyle::TextStyle(Emphasis emphasis)
 	: m_emphasis(emphasis)
@@ -173,4 +173,4 @@ ColorPrintOperatorStyle print(FILE* file, const TextStyle& style)
 	return ColorPrintOperatorStyle(file, style);
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/color.h

@@ -12,9 +12,9 @@
 #include <sstream> // stringstream
 #include <string_view>
 
-#include "util/format/format.h"
+#include "ruc/format/format.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 enum class TerminalColor : uint8_t {
 	None = 0,
@@ -138,19 +138,16 @@ private:
 template<typename T>
 const ColorPrintOperatorStyle& operator<<(const ColorPrintOperatorStyle& colorPrintOperatorStyle, const T& value)
 {
-	_format(const_cast<ColorPrintOperatorStyle&>(colorPrintOperatorStyle).builder(), value);
+	Formatter<T> formatter;
+	formatter.format(const_cast<ColorPrintOperatorStyle&>(colorPrintOperatorStyle).builder(), value);
 	return colorPrintOperatorStyle;
 }
 
 ColorPrintOperatorStyle print(const TextStyle& style);
 ColorPrintOperatorStyle print(FILE* file, const TextStyle& style);
 
-} // namespace Util::Format
+} // namespace ruc::format
 
-namespace Util {
-
-using Util::Format::format;
-using Util::Format::formatTo;
-using Util::Format::print;
-
-} // namespace Util
+using ruc::format::format;
+using ruc::format::formatTo;
+using ruc::format::print;

src/ruc/format/format.cpp

@@ -8,12 +8,12 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/builder.h"
-#include "util/format/format.h"
-#include "util/format/parser.h"
-#include "util/meta/assert.h"
+#include "ruc/format/builder.h"
+#include "ruc/format/format.h"
+#include "ruc/format/parser.h"
+#include "ruc/meta/assert.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 void variadicFormatImpl(Builder& builder, Parser& parser, TypeErasedParameters& parameters)
 {
@@ -73,4 +73,4 @@ FormatOperatorStyle formatTo(std::string& output)
 	return FormatOperatorStyle(output);
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/format.h

@@ -12,9 +12,9 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/formatter.h"
+#include "ruc/format/formatter.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 class Builder;
 class Parser;
@@ -103,17 +103,14 @@ private:
 template<typename T>
 const FormatOperatorStyle& operator<<(const FormatOperatorStyle& formatOperatorStyle, const T& value)
 {
-	_format(const_cast<FormatOperatorStyle&>(formatOperatorStyle).builder(), value);
+	Formatter<T> formatter;
+	formatter.format(const_cast<FormatOperatorStyle&>(formatOperatorStyle).builder(), value);
 	return formatOperatorStyle;
 }
 
 FormatOperatorStyle formatTo(std::string& output);
 
-} // namespace Util::Format
-
-namespace Util {
-
-using Util::Format::format;
-using Util::Format::formatTo;
+} // namespace ruc::format
 
-} // namespace Util
+using ruc::format::format;
+using ruc::format::formatTo;

src/ruc/format/formatter.cpp

@@ -9,11 +9,11 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/builder.h"
-#include "util/format/formatter.h"
-#include "util/format/parser.h"
+#include "ruc/format/builder.h"
+#include "ruc/format/formatter.h"
+#include "ruc/format/parser.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 // Char
 
@@ -114,4 +114,4 @@ type:            {%c}
 	builder.putString(std::string_view(result));
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/formatter.h

@@ -16,11 +16,11 @@
 #include <unordered_map>
 #include <vector>
 
-#include "util/format/builder.h"
-#include "util/format/parser.h"
-#include "util/meta/concepts.h"
+#include "ruc/format/builder.h"
+#include "ruc/format/parser.h"
+#include "ruc/meta/concepts.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 enum class PresentationType : uint8_t {
 	None,
@@ -312,7 +312,7 @@ struct Formatter<Specifier> : Formatter<std::nullptr_t> {
 	void format(Builder& builder, Specifier value) const;
 };
 
-} // namespace Util::Format
+} // namespace ruc::format
 
 #if 0
 

src/ruc/format/log.cpp

@@ -7,10 +7,10 @@
 #include <cstdio> // FILE
 #include <string>
 
-#include "util/format/color.h"
-#include "util/format/log.h"
+#include "ruc/format/color.h"
+#include "ruc/format/log.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 std::string formatTimeElapsed()
 {
@@ -106,4 +106,4 @@ LogOperatorStyle critical()
 	return LogOperatorStyle(stderr, LogType::Critical);
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/log.h

@@ -10,13 +10,13 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/format.h"
-#include "util/format/print.h"
-#include "util/timer.h"
+#include "ruc/format/format.h"
+#include "ruc/format/print.h"
+#include "ruc/timer.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
-static Util::Timer s_timer;
+static Timer s_timer;
 
 enum class LogType : uint8_t {
 	Trace,    // White
@@ -82,16 +82,16 @@ LogOperatorStyle warn();
 LogOperatorStyle error();
 LogOperatorStyle critical();
 
-} // namespace Util::Format
+} // namespace ruc::format
 
-namespace Util {
+namespace ruc {
 
-using Util::Format::critical;
-using Util::Format::debug;
-using Util::Format::error;
-using Util::Format::info;
-using Util::Format::success;
-using Util::Format::trace;
-using Util::Format::warn;
+using ruc::format::critical;
+using ruc::format::debug;
+using ruc::format::error;
+using ruc::format::info;
+using ruc::format::success;
+using ruc::format::trace;
+using ruc::format::warn;
 
-} // namespace Util
+} // namespace ruc

src/ruc/format/parser.cpp

@@ -11,13 +11,13 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/builder.h"
-#include "util/format/formatter.h"
-#include "util/format/parser.h"
-#include "util/format/print.h"
-#include "util/meta/assert.h"
+#include "ruc/format/builder.h"
+#include "ruc/format/formatter.h"
+#include "ruc/format/parser.h"
+#include "ruc/format/print.h"
+#include "ruc/meta/assert.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 Parser::Parser(std::string_view format, size_t parameterCount)
 	: GenericLexer(format)
@@ -282,7 +282,7 @@ void Parser::parseSpecifier(Specifier& specifier, ParameterType type)
 
 	if (!p) {
 		p++;
-		Util::Format::print("{}\n", specifier);
+		print("{}\n", specifier);
 	}
 }
 
@@ -416,4 +416,4 @@ constexpr void Parser::checkSpecifierType(const Specifier& specifier, ParameterT
 	}
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/parser.h

@@ -10,9 +10,9 @@
 #include <optional>
 #include <string_view>
 
-#include "util/genericlexer.h"
+#include "ruc/genericlexer.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 class Builder;
 struct Specifier;
@@ -58,4 +58,4 @@ private:
 	size_t m_parameterCount { 0 };
 };
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/print.cpp

@@ -11,9 +11,9 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/print.h"
+#include "ruc/format/print.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters)
 {
@@ -49,4 +49,4 @@ PrintOperatorStyle print(FILE* file)
 	return PrintOperatorStyle(file);
 }
 
-} // namespace Util::Format
+} // namespace ruc::format

src/ruc/format/print.h

@@ -11,10 +11,10 @@
 #include <sstream> // stringstream
 #include <string_view>
 
-#include "util/format/format.h"
-#include "util/timer.h"
+#include "ruc/format/format.h"
+#include "ruc/timer.h"
 
-namespace Util::Format {
+namespace ruc::format {
 
 void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters);
 
@@ -51,7 +51,8 @@ private:
 template<typename T>
 const PrintOperatorStyle& operator<<(const PrintOperatorStyle& printOperatorStyle, const T& value)
 {
-	_format(const_cast<PrintOperatorStyle&>(printOperatorStyle).builder(), value);
+	Formatter<T> formatter;
+	formatter.format(const_cast<PrintOperatorStyle&>(printOperatorStyle).builder(), value);
 	return printOperatorStyle;
 }
 
@@ -60,10 +61,6 @@ PrintOperatorStyle print(FILE* file);
 
 // -----------------------------------------
 
-} // namespace Util::Format
+} // namespace ruc::format
 
-namespace Util {
-
-using Util::Format::print;
-
-} // namespace Util
+using ruc::format::print;

src/ruc/genericlexer.cpp

@@ -6,10 +6,10 @@
 
 #include <algorithm> // max, min
 
-#include "util/genericlexer.h"
-#include "util/meta/assert.h"
+#include "ruc/genericlexer.h"
+#include "ruc/meta/assert.h"
 
-namespace Util {
+namespace ruc {
 
 GenericLexer::GenericLexer(std::string_view input)
 	: m_input(input)
@@ -68,4 +68,4 @@ bool GenericLexer::consumeSpecific(const char& character)
 	return true;
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/genericlexer.h

@@ -9,7 +9,7 @@
 #include <cstddef> // size_t
 #include <string_view>
 
-namespace Util {
+namespace ruc {
 
 class GenericLexer {
 public:
@@ -38,4 +38,4 @@ protected:
 	std::string_view m_input;
 };
 
-} // namespace Util
+} // namespace ruc

src/ruc/json/array.cpp

@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: MIT
  */
 
-#include "util/json/array.h"
-#include "util/json/value.h"
+#include "ruc/json/array.h"
+#include "ruc/json/value.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 void Array::emplace_back(Value element)
 {
@@ -23,4 +23,4 @@ Value& Array::operator[](size_t index)
 	return m_elements[index];
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/array.h

@@ -9,9 +9,9 @@
 #include <utility> // move
 #include <vector>
 
-#include "util/json/parser.h"
+#include "ruc/json/parser.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Value;
 
@@ -22,7 +22,8 @@ public:
 
 	Array(const std::vector<Value>& elements)
 		: m_elements(elements)
-	{}
+	{
+	}
 
 	Array(const Array& other)
 		: m_elements(other.m_elements)
@@ -53,4 +54,4 @@ private:
 	std::vector<Value> m_elements;
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/fromjson.h

@@ -14,14 +14,14 @@
 #include <utility> // forward
 #include <vector>
 
-#include "util/json/array.h"
-#include "util/json/object.h"
-#include "util/meta/assert.h"
-#include "util/meta/odr.h"
+#include "ruc/json/array.h"
+#include "ruc/json/object.h"
+#include "ruc/meta/assert.h"
+#include "ruc/meta/odr.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
-namespace Detail {
+namespace detail {
 
 // Required for containers with Json::Value type
 template<typename Json>
@@ -107,15 +107,15 @@ struct fromJsonFunction {
 	}
 };
 
-} // namespace Detail
+} // namespace detail
 
 // Anonymous namespace prevents multiple definition of the reference
 namespace {
 // Function object
-constexpr const auto& fromJson = Util::Detail::staticConst<Detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
+constexpr const auto& fromJson = ruc::detail::staticConst<detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
 } // namespace
 
-} // namespace Util::JSON
+} // namespace ruc::json
 
 // Customization Points
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

src/ruc/json/job.cpp

@@ -8,12 +8,12 @@
 #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"
+#include "ruc/json/job.h"
+#include "ruc/json/lexer.h"
+#include "ruc/json/parser.h"
+#include "ruc/json/value.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 Job::Job(std::string_view input)
 	: m_input(input)
@@ -111,4 +111,4 @@ void Job::printErrorLine(Token token, const char* message)
 	        std::string(line.length() - token.column, '~').c_str());
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/job.h

@@ -10,9 +10,9 @@
 #include <string_view>
 #include <vector>
 
-#include "util/json/lexer.h"
+#include "ruc/json/lexer.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Value;
 
@@ -38,4 +38,4 @@ private:
 	std::vector<Token> m_tokens;
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/json.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2022 Riyyi
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include "ruc/json/value.h"
+
+namespace ruc {
+
+using Json = ruc::json::Value;
+
+} // namespace ruc

src/ruc/json/lexer.cpp

@@ -7,10 +7,10 @@
 #include <cstddef>
 #include <string>
 
-#include "util/json/job.h"
-#include "util/json/lexer.h"
+#include "ruc/json/job.h"
+#include "ruc/json/lexer.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 Lexer::Lexer(Job* job)
 	: GenericLexer(job->input())
@@ -214,4 +214,4 @@ bool Lexer::consumeLiteral()
 	return consumeNumberOrLiteral(Token::Type::Literal);
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/lexer.h

@@ -14,9 +14,9 @@
 #include <string>
 #include <vector>
 
-#include "util/genericlexer.h"
+#include "ruc/genericlexer.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Job;
 
@@ -41,7 +41,7 @@ struct Token {
 };
 
 // Lexical analyzer
-class Lexer final : public Util::GenericLexer {
+class Lexer final : public GenericLexer {
 public:
 	Lexer(Job* job);
 	virtual ~Lexer();
@@ -62,4 +62,4 @@ private:
 	std::vector<Token>* m_tokens { nullptr };
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/object.cpp

@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: MIT
  */
 
-#include "util/json/object.h"
-#include "util/json/value.h"
+#include "ruc/json/object.h"
+#include "ruc/json/value.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 void Object::emplace(const std::string& name, Value value)
 {
@@ -23,4 +23,4 @@ Value& Object::operator[](const std::string& name)
 	return m_members.at(name);
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/object.h

@@ -10,9 +10,9 @@
 #include <string>
 #include <utility> // move
 
-#include "util/json/parser.h"
+#include "ruc/json/parser.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Value;
 
@@ -49,4 +49,4 @@ private:
 	std::map<std::string, Value> m_members;
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/parser.cpp

@@ -11,15 +11,15 @@
 #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"
-#include "util/meta/assert.h"
+#include "ruc/json/array.h"
+#include "ruc/json/job.h"
+#include "ruc/json/lexer.h"
+#include "ruc/json/object.h"
+#include "ruc/json/parser.h"
+#include "ruc/json/value.h"
+#include "ruc/meta/assert.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 Parser::Parser(Job* job)
 	: m_job(job)
@@ -494,4 +494,4 @@ Value Parser::consumeObject()
 	return object;
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/parser.h

@@ -9,9 +9,9 @@
 #include <cstddef> // size_t
 #include <vector>
 
-#include "util/json/lexer.h"
+#include "ruc/json/lexer.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Job;
 class Value;
@@ -42,4 +42,4 @@ private:
 	std::vector<Token>* m_tokens { nullptr };
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/serializer.cpp

@@ -9,12 +9,12 @@
 #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"
+#include "ruc/json/array.h"
+#include "ruc/json/lexer.h"
+#include "ruc/json/object.h"
+#include "ruc/json/serializer.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 Serializer::Serializer(const uint32_t indent, const char indentCharacter)
 	: m_indent(indent)
@@ -152,4 +152,4 @@ void Serializer::dumpObject(const Value& value, const uint32_t indentLevel)
 	m_output += '}';
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/serializer.h

@@ -9,9 +9,9 @@
 #include <cstdint> // uint32_t
 #include <string>
 
-#include "util/json/value.h"
+#include "ruc/json/value.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Serializer {
 public:
@@ -32,4 +32,4 @@ private:
 	bool m_compact { true };
 };
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/tojson.h

@@ -13,13 +13,13 @@
 #include <unordered_map>
 #include <utility> // forward
 
-#include "util/json/array.h"
-#include "util/json/object.h"
-#include "util/meta/odr.h"
+#include "ruc/json/array.h"
+#include "ruc/json/object.h"
+#include "ruc/meta/odr.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
-namespace Detail {
+namespace detail {
 
 struct jsonConstructor {
 	template<typename Json>
@@ -127,15 +127,15 @@ struct toJsonFunction {
 	}
 };
 
-} // namespace Detail
+} // namespace detail
 
 // Anonymous namespace prevents multiple definition of the reference
 namespace {
 // Function object
-constexpr const auto& toJson = Util::Detail::staticConst<Detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
+constexpr const auto& toJson = ruc::detail::staticConst<detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
 } // namespace
 
-} // namespace Util::JSON
+} // namespace ruc::json
 
 // Customization Points
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

src/ruc/json/value.cpp

@@ -11,15 +11,15 @@
 #include <string>
 #include <utility> // move, swap
 
-#include "util/format/builder.h"
-#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"
-#include "util/meta/assert.h"
+#include "ruc/format/builder.h"
+#include "ruc/meta/assert.h"
+#include "ruc/json/array.h"
+#include "ruc/json/job.h"
+#include "ruc/json/object.h"
+#include "ruc/json/serializer.h"
+#include "ruc/json/value.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 Value::Value(std::nullptr_t)
 	: Value(Type::Null)
@@ -332,9 +332,9 @@ std::ostream& operator<<(std::ostream& output, const Value& value)
 	return output << value.dump(4);
 }
 
-void format(Util::Format::Builder& builder, const Value& value)
+void format(ruc::format::Builder& builder, const Value& value)
 {
 	builder.putString(value.dump(4));
 }
 
-} // namespace Util::JSON
+} // namespace ruc::json

src/ruc/json/value.h

@@ -13,18 +13,18 @@
 #include <string>
 #include <utility> // forward
 
-#include "util/format/builder.h"
-#include "util/json/fromjson.h"
-#include "util/json/tojson.h"
+#include "ruc/format/builder.h"
+#include "ruc/json/fromjson.h"
+#include "ruc/json/tojson.h"
 
-namespace Util::JSON {
+namespace ruc::json {
 
 class Array;
 class Object;
 
 class Value {
 private:
-	friend Detail::jsonConstructor;
+	friend detail::jsonConstructor;
 	friend class Parser;
 	friend class Serializer;
 
@@ -134,32 +134,16 @@ private:
 std::istream& operator>>(std::istream& input, Value& value);
 std::ostream& operator<<(std::ostream& output, const Value& value);
 
-void format(Util::Format::Builder& builder, const Value& value);
+void format(ruc::format::Builder& builder, const Value& value);
 
-} // namespace Util::JSON
+} // namespace ruc::json
 
 /**
  * User-defined string literal
  *
  * Example usage: auto json = "[ 3.14, true, null ]"_json;
  */
-// inline Util::JSON::Value operator"" _json(const char* input, size_t length)
-// {
-// 	return Util::JSON::Value::parse(std::string(input, length));
-// }
-
-// TODO:
-// - find
-// - custom iterator
-//   - begin
-//   - end
-// v parse function that accepts ifstream > redirect to operator>>
-// - dump(-1), 0 inserts only newlines, -1 is full compact(?)
-// v add timer pause and unpause functions
-// v std::prev -> std::next in serializer
-// v serializer: output as member, does this speed it up?
-// - add Badge pattern, ex: Serializer constructor isnt needed publically
-// v Rename namespace Json -> Util::Json, create easy include json.h
-
-// - look into this for correctness
-//     https://www.json.org/json-en.html
+inline ruc::json::Value operator"" _json(const char* input, size_t length)
+{
+	return ruc::json::Value::parse(std::string(input, length));
+}

src/ruc/meta/assert.h

@@ -13,13 +13,13 @@
 #include <string>
 #include <string_view>
 
-#include "util/format/format.h"
-#include "util/meta/compiler.h"
+#include "ruc/format/format.h"
+#include "ruc/meta/compiler.h"
 
 #define CRASH() asm volatile("int $0x03");
 
 #ifndef NDEBUG
-	#define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : Util::__assertion_failed(#expr, __FILE__, __LINE__, FUNCTION_MACRO __VA_OPT__(, ) __VA_ARGS__))
+	#define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : ruc::__assertion_failed(#expr, __FILE__, __LINE__, FUNCTION_MACRO __VA_OPT__(, ) __VA_ARGS__))
 	#define VERIFY_NOT_REACHED() VERIFY(false)
 #else
 	#define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : CRASH()
@@ -27,7 +27,7 @@
 #endif
 
 #ifndef NDEBUG
-namespace Util {
+namespace ruc {
 
 template<typename... Parameters>
 inline void __assertion_failed(const char* assertion, const char* file, uint32_t line, const char* function, const Parameters&... parameters)
@@ -66,8 +66,8 @@ inline void __assertion_failed(const char* assertion, const char* file, uint32_t
 		fprintf(stderr, ": ");
 		// Cant use the formatting library to print asserts caused by the formatting library
 		std::string_view functionString = function;
-		if (functionString.find("Util::Format::") != std::string_view::npos
-		    && functionString.find("Util::GenericLexer::") != std::string_view::npos) {
+		if (functionString.find("ruc::format::") != std::string_view::npos
+		    && functionString.find("ruc::GenericLexer::") != std::string_view::npos) {
 			std::string message;
 			formatTo(message, parameters...);
 			fprintf(stderr, "%s", message.c_str());
@@ -92,5 +92,5 @@ inline void __assertion_failed(const char* assertion, const char* file, uint32_t
 	CRASH();
 }
 
-} // namespace Util
+} // namespace ruc
 #endif

src/ruc/meta/concepts.h

@@ -8,7 +8,7 @@
 
 #include <type_traits> // is_integral_v, floating_point_v
 
-namespace Util::Concepts {
+namespace ruc::concepts {
 
 template<class T>
 concept Integral = std::is_integral_v<T>;
@@ -16,7 +16,7 @@ concept Integral = std::is_integral_v<T>;
 template<typename T>
 concept FloatingPoint = std::is_floating_point_v<T>;
 
-} // namespace Util::Concepts
+} // namespace ruc::concepts
 
-using Util::Concepts::FloatingPoint;
-using Util::Concepts::Integral;
+using ruc::concepts::FloatingPoint;
+using ruc::concepts::Integral;

src/ruc/meta/odr.h

@@ -6,15 +6,15 @@
 
 #pragma once
 
-namespace Util {
+namespace ruc {
 
-namespace Detail {
+namespace detail {
 
 // Avoid ODR (One Definition Rule) violations,
 // variable templates are required to have external linkage
 template<typename T>
 constexpr T staticConst {};
 
-} // namespace Detail
+} // namespace detail
 
-} // namespace Util
+} // namespace ruc

src/ruc/shell.cpp

@@ -2,9 +2,9 @@
 #include <string>
 #include <string_view>
 
-#include "util/shell.h"
+#include "ruc/shell.h"
 
-namespace Util {
+namespace ruc {
 
 Shell::Shell()
 {
@@ -50,4 +50,4 @@ Shell Shell::operator()(std::string_view command)
 	return operator()(command.data());
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/shell.h

@@ -9,7 +9,7 @@
 #include <string>
 #include <string_view>
 
-namespace Util {
+namespace ruc {
 
 class Shell {
 public:
@@ -30,4 +30,4 @@ private:
 	int m_status { 0 };
 };
 
-} // namespace Util
+} // namespace ruc

src/ruc/singleton.h

@@ -8,7 +8,7 @@
 
 #include <cassert>
 
-namespace Util {
+namespace ruc {
 
 template<typename T>
 class Singleton {
@@ -50,4 +50,4 @@ private:
 template<typename T>
 T* Singleton<T>::s_instance = nullptr;
 
-} // namespace Util
+} // namespace ruc

src/ruc/system.cpp

@@ -11,9 +11,9 @@
 #include <unistd.h>   // close, dup2, execvp, fork, pipe, read
 #include <vector>
 
-#include "util/system.h"
+#include "ruc/system.h"
 
-namespace Util {
+namespace ruc {
 
 System::System()
 {
@@ -325,4 +325,4 @@ void System::readFromFileDescriptor(int fileDescriptor[2], std::string& output)
 	close(fileDescriptor[ReadFileDescriptor]);
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/system.h

@@ -12,7 +12,7 @@
 #include <string_view>
 #include <vector>
 
-namespace Util {
+namespace ruc {
 
 using LineCallback = std::function<void(std::vector<std::string>&)>;
 
@@ -65,4 +65,4 @@ private:
 	int m_status { 0 };
 };
 
-} // namespace Util
+} // namespace ruc

src/ruc/timer.cpp

@@ -2,9 +2,9 @@
 #include <cstdint> // uint64_t
 #include <cstdio>  // printf
 
-#include "util/timer.h"
+#include "ruc/timer.h"
 
-namespace Util {
+namespace ruc {
 
 Timer::Timer()
 	: m_running(true)
@@ -128,4 +128,4 @@ void Timer::fancyPrint(uint64_t nanoseconds)
 	}
 }
 
-} // namespace Util
+} // namespace ruc

src/ruc/timer.h

@@ -9,7 +9,7 @@
 #include <chrono>  // high_resolution_clock
 #include <cstdint> // uint64_t
 
-namespace Util {
+namespace ruc {
 
 using TimePoint = std::chrono::high_resolution_clock::time_point;
 
@@ -48,4 +48,4 @@ private:
 	TimePoint m_start;
 };
 
-} // namespace Util
+} // namespace ruc

src/util/json/json.h

@@ -1,15 +0,0 @@
-/*
- * Copyright (C) 2022 Riyyi
- *
- * SPDX-License-Identifier: MIT
- */
-
-#pragma once
-
-#include "util/json/value.h"
-
-namespace Util {
-
-using Json = Util::JSON::Value;
-
-} // namespace Util

test/macro.h

@@ -20,7 +20,7 @@
 	if (!(x)) {                                                                \
 		fprintf(stderr, " \033[31;1mFAIL:\033[0m  %s:%d: EXPECT(%s) failed\n", \
 		        __FILE__, __LINE__, #x);                                       \
-		Test::TestSuite::the().currentTestCaseFailed();                        \
+		test::TestSuite::the().currentTestCaseFailed();                        \
 		result;                                                                \
 	}
 
@@ -41,7 +41,7 @@
 		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();                         \
+		test::TestSuite::the().currentTestCaseFailed();                         \
 		result;                                                                 \
 	}
 
@@ -62,7 +62,7 @@
 		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();                         \
+		test::TestSuite::the().currentTestCaseFailed();                         \
 		result;                                                                 \
 	}
 

test/main.cpp

@@ -2,7 +2,7 @@
 
 int main(int, const char*[])
 {
-	Test::TestSuite::the().run();
+	test::TestSuite::the().run();
 
 	return 0;
 }

test/testcase.h

@@ -13,14 +13,14 @@
 		__TEST_CASE_STRUCT(x)                                  \
 		()                                                     \
 		{                                                      \
-			Test::TestSuite::the().addCase(                    \
+			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 {
+namespace test {
 
 using TestFunction = std::function<void()>;
 
@@ -40,6 +40,6 @@ private:
 	TestFunction m_function;
 };
 
-} // namespace Test
+} // namespace test
 
 #endif // TEST_CASE_H

test/testsuite.cpp

@@ -3,10 +3,10 @@
 #include <string>
 #include <vector>
 
+#include "ruc/timer.h"
 #include "testsuite.h"
-#include "util/timer.h"
 
-namespace Test {
+namespace test {
 
 TestSuite::TestSuite(s)
 {
@@ -32,7 +32,7 @@ void TestSuite::run()
 	printf("\n");
 	printf("---- Running %zu Test Cases ----\n", m_cases.size());
 
-	Util::Timer totalTimer;
+	ruc::Timer totalTimer;
 
 	size_t caseFailedCount = 0;
 	for (size_t i = 0; i < m_cases.size(); ++i) {
@@ -40,7 +40,7 @@ void TestSuite::run()
 		printf(" START  %s (%zu/%zu)\n", m_cases.at(i).name(), i + 1, m_cases.size());
 		m_currentTestCasePassed = true;
 
-		Util::Timer caseTimer;
+		ruc::Timer caseTimer;
 		m_cases.at(i).function()();
 		double elapsed = caseTimer.elapsedNanoseconds();
 
@@ -58,7 +58,7 @@ void TestSuite::run()
 		}
 
 		printf("%s %s %s(", state.c_str(), m_cases.at(i).name(), escapeGrey);
-		Util::Timer::fancyPrint(elapsed);
+		ruc::Timer::fancyPrint(elapsed);
 		printf(")%s\n", escapeReset);
 	}
 
@@ -69,8 +69,8 @@ void TestSuite::run()
 	       m_cases.size());
 
 	printf("Time:   ");
-	Util::Timer::fancyPrint(totalTimer.elapsedNanoseconds());
+	ruc::Timer::fancyPrint(totalTimer.elapsedNanoseconds());
 	printf("\n");
 }
 
-} // namespace Test
+} // namespace test

test/testsuite.h

@@ -4,12 +4,12 @@
 #include <cstdio> // FILE
 #include <vector>
 
+#include "ruc/singleton.h"
 #include "testcase.h"
-#include "util/singleton.h"
 
-namespace Test {
+namespace test {
 
-class TestSuite final : public Util::Singleton<TestSuite> {
+class TestSuite final : public ruc::Singleton<TestSuite> {
 public:
 	TestSuite(s);
 	virtual ~TestSuite();
@@ -31,6 +31,6 @@ private:
 	std::vector<TestCase> m_cases;
 };
 
-} // namespace Test
+} // namespace test
 
 #endif // TEST_SUITE_H

test/unit/testutilargparser.cpp

@@ -3,15 +3,15 @@
 #include <vector>
 
 #include "macro.h"
+#include "ruc/argparser.h"
 #include "testcase.h"
 #include "testsuite.h"
-#include "util/argparser.h"
 
-bool runParser(std::vector<const char*> arguments, std::function<void(Util::ArgParser&)> initializer = {})
+bool runParser(std::vector<const char*> arguments, std::function<void(ruc::ArgParser&)> initializer = {})
 {
-	stdout = Test::TestSuite::the().outputNull();
+	stdout = test::TestSuite::the().outputNull();
 
-	Util::ArgParser parser;
+	ruc::ArgParser parser;
 	if (initializer) {
 		initializer(parser);
 	}
@@ -19,7 +19,7 @@ bool runParser(std::vector<const char*> arguments, std::function<void(Util::ArgP
 	arguments.insert(arguments.begin(), "app");
 	auto result = parser.parse(arguments.size(), arguments.data());
 
-	stdout = Test::TestSuite::the().outputStd();
+	stdout = test::TestSuite::the().outputStd();
 	return result;
 }
 
@@ -55,7 +55,7 @@ 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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my-required-argument");
@@ -63,7 +63,7 @@ TEST_CASE(RequiredStringArguments)
 	// Single required string argument, not given
 	stringArg1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringArg1, "");
@@ -73,9 +73,9 @@ TEST_CASE(RequiredStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my");
@@ -87,9 +87,9 @@ TEST_CASE(RequiredStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringArg1, "");
@@ -104,7 +104,7 @@ 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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my-optional-argument");
@@ -112,7 +112,7 @@ TEST_CASE(OptionalStringArguments)
 	// Single optional string argument, not given
 	stringArg1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "");
@@ -122,9 +122,9 @@ TEST_CASE(OptionalStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my");
@@ -136,9 +136,9 @@ TEST_CASE(OptionalStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "");
@@ -153,7 +153,7 @@ 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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my-non-required-argument");
@@ -161,7 +161,7 @@ TEST_CASE(NonRequiredStringArguments)
 	// Single non-required string argument, not given
 	stringArg1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "");
@@ -171,9 +171,9 @@ TEST_CASE(NonRequiredStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "my");
@@ -185,9 +185,9 @@ TEST_CASE(NonRequiredStringArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringArg1, "");
@@ -202,7 +202,7 @@ 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);
+		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(vectorArg1.size(), 0);
@@ -210,7 +210,7 @@ TEST_CASE(VectorStringArguments)
 	// Required vector string argument, one given
 	vectorArg1 = {};
 	result = runParser({ "foo" }, [&](auto& parser) {
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
+		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorArg1.size(), 1);
@@ -221,7 +221,7 @@ TEST_CASE(VectorStringArguments)
 	// Required vector string argument, two given
 	vectorArg1 = {};
 	result = runParser({ "hello", "world" }, [&](auto& parser) {
-		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
+		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorArg1.size(), 2);
@@ -240,9 +240,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
 	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);
+		parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(intArg1, 0);
@@ -254,9 +254,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
 	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);
+		parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(intArg1, 0);
@@ -268,9 +268,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
 	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);
+		parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(intArg1, 0);
@@ -282,9 +282,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
 	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);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringArg1, "999.999");
@@ -360,7 +360,7 @@ 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-required-argument");
@@ -368,7 +368,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-required-argument");
@@ -376,7 +376,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringOpt1, "");
@@ -384,7 +384,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// Single required string short option, not given
 	stringOpt1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -392,7 +392,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-required-argument");
@@ -400,7 +400,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-required-argument");
@@ -408,7 +408,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringOpt1, "");
@@ -416,7 +416,7 @@ TEST_CASE(SingleRequiredStringOptions)
 	// Single required string long option, not given
 	stringOpt1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -430,8 +430,8 @@ TEST_CASE(SingleOptionalStringOptions)
 	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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -440,7 +440,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-optional-argument");
@@ -448,7 +448,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -456,7 +456,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// Single optional string short option, not given
 	stringOpt1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -465,8 +465,8 @@ TEST_CASE(SingleOptionalStringOptions)
 	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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -475,7 +475,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "my-optional-argument");
@@ -483,7 +483,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -491,7 +491,7 @@ TEST_CASE(SingleOptionalStringOptions)
 	// Single optional string long option, not given
 	stringOpt1 = "";
 	result = runParser({}, [&](auto& parser) {
-		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -505,8 +505,8 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -515,7 +515,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringOpt1, "");
@@ -523,7 +523,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -531,7 +531,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -540,8 +540,8 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
+		parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -550,7 +550,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(stringOpt1, "");
@@ -558,7 +558,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -566,7 +566,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
 	// 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);
+		parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(stringOpt1, "");
@@ -579,7 +579,7 @@ 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);
+		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(intOpt1, 2147483647);
@@ -587,7 +587,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(intOpt1, 0);
@@ -595,7 +595,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(intOpt1, 0);
@@ -603,7 +603,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(unsignedIntOpt1, 4294967295);
@@ -611,7 +611,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(unsignedIntOpt1, 0);
@@ -619,7 +619,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(unsignedIntOpt1, 0);
@@ -627,7 +627,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(doubleOpt1, 999.999);
@@ -635,7 +635,7 @@ TEST_CASE(NumberOptions)
 	// 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);
+		parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(doubleOpt1, 0);
@@ -648,7 +648,7 @@ 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);
+		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 0);
@@ -656,7 +656,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(vectorOpt1.size(), 0);
@@ -664,7 +664,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 1);
@@ -675,7 +675,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 2);
@@ -687,7 +687,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 2);
@@ -699,7 +699,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(vectorOpt1.size(), 0);
@@ -707,7 +707,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 1);
@@ -718,7 +718,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 2);
@@ -730,7 +730,7 @@ TEST_CASE(VectorStringOptions)
 	// 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);
+		parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 	});
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(vectorOpt1.size(), 2);
@@ -750,7 +750,7 @@ TEST_CASE(MultipleOptions)
 	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.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
 		parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
 	});
 	EXPECT_EQ(result, true);

test/unit/testutilformat.cpp

@@ -13,9 +13,9 @@
 #include <vector>
 
 #include "macro.h"
+#include "ruc/format/format.h"
 #include "testcase.h"
 #include "testsuite.h"
-#include "util/format/format.h"
 
 // -----------------------------------------
 
@@ -26,37 +26,37 @@ TEST_CASE(FormatIntegral)
 	// Signed
 
 	int8_t i8 = 127; // char
-	result = Util::format("{}", i8);
+	result = format("{}", i8);
 	EXPECT_EQ(result, "127");
 
 	int16_t i16 = 32767;
-	result = Util::format("{}", i16);
+	result = format("{}", i16);
 	EXPECT_EQ(result, "32767");
 
 	int32_t i32 = 68766; // int
-	result = Util::format("{}", i32);
+	result = format("{}", i32);
 	EXPECT_EQ(result, "68766");
 
 	int64_t i64 = 237942768427; // long int
-	result = Util::format("{}", i64);
+	result = format("{}", i64);
 	EXPECT_EQ(result, "237942768427");
 
 	// Unsigned
 
 	uint8_t u8 = 255; // unsigned char
-	result = Util::format("{}", u8);
+	result = format("{}", u8);
 	EXPECT_EQ(result, "255");
 
 	uint16_t u16 = 65535;
-	result = Util::format("{}", u16);
+	result = format("{}", u16);
 	EXPECT_EQ(result, "65535");
 
 	uint32_t u32 = 4294967295; // unsigned int
-	result = Util::format("{}", u32);
+	result = format("{}", u32);
 	EXPECT_EQ(result, "4294967295");
 
 	size_t u64 = 18446744073709551615; // long unsigned int
-	result = Util::format("{}", u64);
+	result = format("{}", u64);
 	EXPECT_EQ(result, "18446744073709551615");
 }
 
@@ -65,19 +65,19 @@ TEST_CASE(FormatFloatingPoint)
 	std::string result;
 
 	float f32R = 245789.70000;
-	result = Util::format("{}", f32R);
+	result = format("{}", f32R);
 	EXPECT_EQ(result, "245789.703125");
 
 	float f32 = 45645.3233;
-	result = Util::format("{}", f32);
+	result = format("{}", f32);
 	EXPECT_EQ(result, "45645.324219");
 
 	double f64 = 87522.300000000;
-	result = Util::format("{}", f64);
+	result = format("{}", f64);
 	EXPECT_EQ(result, "87522.300000");
 
 	double pi = 3.14159265359;
-	result = Util::format("{}", pi);
+	result = format("{}", pi);
 	EXPECT_EQ(result, "3.141593");
 }
 
@@ -86,15 +86,15 @@ TEST_CASE(FormatChar)
 	std::string result;
 
 	char character = 'A';
-	result = Util::format("{}", character);
+	result = format("{}", character);
 	EXPECT_EQ(result, "A");
 
 	bool boolean = true;
-	result = Util::format("{}", boolean);
+	result = format("{}", boolean);
 	EXPECT_EQ(result, "true");
 
 	boolean = false;
-	result = Util::format("{}", boolean);
+	result = format("{}", boolean);
 	EXPECT_EQ(result, "false");
 }
 
@@ -102,28 +102,28 @@ TEST_CASE(FormatString)
 {
 	std::string result;
 
-	result = Util::format("");
+	result = format("");
 	EXPECT_EQ(result, "");
 
 	const char* cString = "C string";
-	result = Util::format("{}", cString);
+	result = format("{}", cString);
 	EXPECT_EQ(result, "C string");
 
 	std::string string = "string";
-	result = Util::format("{}", string);
+	result = format("{}", string);
 	EXPECT_EQ(result, "string");
 
 	std::string_view stringView = "string_view";
-	result = Util::format("{}", stringView);
+	result = format("{}", stringView);
 	EXPECT_EQ(result, "string_view");
 
-	result = Util::format("{} {}", "Hello", "World");
+	result = format("{} {}", "Hello", "World");
 	EXPECT_EQ(result, "Hello World");
 
-	result = Util::format("{{escaped braces}}");
+	result = format("{{escaped braces}}");
 	EXPECT_EQ(result, "{escaped braces}");
 
-	result = Util::format("{{braces{}}}", "Something");
+	result = format("{{braces{}}}", "Something");
 	EXPECT_EQ(result, "{bracesSomething}");
 }
 
@@ -131,7 +131,7 @@ TEST_CASE(FormatPointer)
 {
 	std::string result;
 
-	result = Util::format("{}", nullptr);
+	result = format("{}", nullptr);
 	EXPECT_EQ(result, "0x0");
 
 	int integer = 42;
@@ -139,7 +139,7 @@ TEST_CASE(FormatPointer)
 	stream << &integer;
 	std::string pointer = stream.str();
 
-	result = Util::format("{}", &integer);
+	result = format("{}", &integer);
 	EXPECT_EQ(result, pointer);
 }
 
@@ -148,80 +148,80 @@ TEST_CASE(FormatSpecifierIntegral)
 	std::string result;
 
 	// Fill and Align
-	result = Util::format("{:+<}", 12345);
+	result = format("{:+<}", 12345);
 	EXPECT_EQ(result, "12345");
-	result = Util::format("{:+^}", 12345);
+	result = format("{:+^}", 12345);
 	EXPECT_EQ(result, "12345");
-	result = Util::format("{:+>}", 12345);
+	result = format("{:+>}", 12345);
 	EXPECT_EQ(result, "12345");
 
 	// Sign
-	result = Util::format("{:+}", 12345);
+	result = format("{:+}", 12345);
 	EXPECT_EQ(result, "+12345");
-	result = Util::format("{:+}", -12345);
+	result = format("{:+}", -12345);
 	EXPECT_EQ(result, "-12345");
-	result = Util::format("{:-}", 12345);
+	result = format("{:-}", 12345);
 	EXPECT_EQ(result, "12345");
-	result = Util::format("{:-}", -12345);
+	result = format("{:-}", -12345);
 	EXPECT_EQ(result, "-12345");
-	result = Util::format("{: }", 12345);
+	result = format("{: }", 12345);
 	EXPECT_EQ(result, " 12345");
-	result = Util::format("{: }", -12345);
+	result = format("{: }", -12345);
 	EXPECT_EQ(result, "-12345");
 
 	// AlternativeForm
-	result = Util::format("{:#}", 12345);
+	result = format("{:#}", 12345);
 	EXPECT_EQ(result, "12345");
 
 	// ZeroPadding
-	result = Util::format("{:0}", 12345);
+	result = format("{:0}", 12345);
 	EXPECT_EQ(result, "12345");
 
 	// Width
-	result = Util::format("{:10}", 12345);
+	result = format("{:10}", 12345);
 	EXPECT_EQ(result, "     12345");
 
 	// Width + Fill and Align
-	result = Util::format("{:+<10}", 12345);
+	result = format("{:+<10}", 12345);
 	EXPECT_EQ(result, "12345+++++");
-	result = Util::format("{:+^10}", 12345);
+	result = format("{:+^10}", 12345);
 	EXPECT_EQ(result, "++12345+++");
-	result = Util::format("{:+>10}", 12345);
+	result = format("{:+>10}", 12345);
 	EXPECT_EQ(result, "+++++12345");
 
 	// Width + ZeroPadding
-	result = Util::format("{:010}", 12345);
+	result = format("{:010}", 12345);
 	EXPECT_EQ(result, "0000012345");
 
 	// Precision
 	// Not possible on integral types
 
 	// Type
-	result = Util::format("{:b}", 12345);
+	result = format("{:b}", 12345);
 	EXPECT_EQ(result, "11000000111001");
-	result = Util::format("{:B}", 12345);
+	result = format("{:B}", 12345);
 	EXPECT_EQ(result, "11000000111001");
-	result = Util::format("{:c}", 65);
+	result = format("{:c}", 65);
 	EXPECT_EQ(result, "A");
-	result = Util::format("{:o}", 12345);
+	result = format("{:o}", 12345);
 	EXPECT_EQ(result, "30071");
-	result = Util::format("{:x}", 62432);
+	result = format("{:x}", 62432);
 	EXPECT_EQ(result, "f3e0");
-	result = Util::format("{:X}", 62432);
+	result = format("{:X}", 62432);
 	EXPECT_EQ(result, "F3E0");
 
 	// Type + AlternativeForm
-	result = Util::format("{:#b}", 12345);
+	result = format("{:#b}", 12345);
 	EXPECT_EQ(result, "0b11000000111001");
-	result = Util::format("{:#B}", 12345);
+	result = format("{:#B}", 12345);
 	EXPECT_EQ(result, "0B11000000111001");
-	result = Util::format("{:#c}", 65);
+	result = format("{:#c}", 65);
 	EXPECT_EQ(result, "A");
-	result = Util::format("{:#o}", 12345);
+	result = format("{:#o}", 12345);
 	EXPECT_EQ(result, "030071");
-	result = Util::format("{:#x}", 62432);
+	result = format("{:#x}", 62432);
 	EXPECT_EQ(result, "0xf3e0");
-	result = Util::format("{:#X}", 62432);
+	result = format("{:#X}", 62432);
 	EXPECT_EQ(result, "0XF3E0");
 }
 
@@ -232,78 +232,78 @@ TEST_CASE(FormatSpecifierIntegralCombination)
 	// AlternativeForm + ZeroPadding + Width + Type
 	// ------------------------------
 
-	result = Util::format("{:-#010d}", 402);
+	result = format("{:-#010d}", 402);
 	EXPECT_EQ(result, "0000000402");
 
 	// AlternativeForm + Width + Type
 	// ------------------------------
 
-	result = Util::format("{:#10x}", 402);
+	result = format("{:#10x}", 402);
 	EXPECT_EQ(result, "     0x192");
 
 	// + Fill and Align
 
-	result = Util::format("{:^<#10x}", 402);
+	result = format("{:^<#10x}", 402);
 	EXPECT_EQ(result, "0x192^^^^^");
 
-	result = Util::format("{:^^#10x}", 402);
+	result = format("{:^^#10x}", 402);
 	EXPECT_EQ(result, "^^0x192^^^");
 
-	result = Util::format("{:^>#10x}", 402);
+	result = format("{:^>#10x}", 402);
 	EXPECT_EQ(result, "^^^^^0x192");
 
 	// ------------------------------
 
 	// + Sign
 
-	result = Util::format("{:+#10x}", 402);
+	result = format("{:+#10x}", 402);
 	EXPECT_EQ(result, "    +0x192");
 
 	// + Fill and Align + Sign
 
-	result = Util::format("{:^<+#10x}", 402);
+	result = format("{:^<+#10x}", 402);
 	EXPECT_EQ(result, "+0x192^^^^");
 
-	result = Util::format("{:^^+#10x}", 402);
+	result = format("{:^^+#10x}", 402);
 	EXPECT_EQ(result, "^^+0x192^^");
 
-	result = Util::format("{:^>+#10x}", 402);
+	result = format("{:^>+#10x}", 402);
 	EXPECT_EQ(result, "^^^^+0x192");
 
 	// ------------------------------
 
 	// + ZeroPadding
 
-	result = Util::format("{:#010x}", 402);
+	result = format("{:#010x}", 402);
 	EXPECT_EQ(result, "0x00000192");
 
 	// Fill and Align + ZeroPadding
 
-	result = Util::format("{:^<#010x}", 402);
+	result = format("{:^<#010x}", 402);
 	EXPECT_EQ(result, "0x19200000");
 
-	result = Util::format("{:^^#010x}", 402);
+	result = format("{:^^#010x}", 402);
 	EXPECT_EQ(result, "000x192000");
 
-	result = Util::format("{:^>#010x}", 402);
+	result = format("{:^>#010x}", 402);
 	EXPECT_EQ(result, "000000x192");
 
 	// ------------------------------
 
 	// + Sign + ZeroPadding
 
-	result = Util::format("{:+#010x}", 402);
+	result = format("{:+#010x}", 402);
 	EXPECT_EQ(result, "+0x0000192");
 
 	// + Fill and Align + Sign + ZeroPadding
 
-	result = Util::format("{:^<+#010x}", 402);
+	result = format("{:^<+#010x}", 402);
 	EXPECT_EQ(result, "+0x1920000");
 
-	result = Util::format("{:^^+#010x}", 402);
+	result = format("{:^^+#010x}", 402);
 	EXPECT_EQ(result, "00+0x19200");
 
-	result = Util::format("{:^>+#010x}", 402);
+	result = format("{:^>+#010x}", 402);
 	EXPECT_EQ(result, "0000+0x192");
 }
 
@@ -312,14 +312,14 @@ TEST_CASE(FormatSpecifierFloatingPoint)
 	std::string result;
 
 	double f64 = 87522.300000000;
-	result = Util::format("{:.1}", f64);
+	result = format("{:.1}", f64);
 	EXPECT_EQ(result, "87522.3");
 
 	double pi = 3.14159265359;
-	result = Util::format("{}", pi);
+	result = format("{}", pi);
 	EXPECT_EQ(result, "3.141593");
 
-	result = Util::format("{:.15}", pi);
+	result = format("{:.15}", pi);
 	EXPECT_EQ(result, "3.141592653590000");
 }
 
@@ -328,45 +328,45 @@ TEST_CASE(FormatSpecifierChar)
 	std::string result;
 
 	char character = 65;
-	result = Util::format("{:b}", character);
+	result = format("{:b}", character);
 	EXPECT_EQ(result, "1000001");
-	result = Util::format("{:B}", character);
+	result = format("{:B}", character);
 	EXPECT_EQ(result, "1000001");
-	result = Util::format("{:d}", character);
+	result = format("{:d}", character);
 	EXPECT_EQ(result, "65");
-	result = Util::format("{:o}", character);
+	result = format("{:o}", character);
 	EXPECT_EQ(result, "101");
-	result = Util::format("{:x}", character);
+	result = format("{:x}", character);
 	EXPECT_EQ(result, "41");
-	result = Util::format("{:X}", character);
+	result = format("{:X}", character);
 	EXPECT_EQ(result, "41");
 
 	bool boolean = true;
-	result = Util::format("{:b}", boolean);
+	result = format("{:b}", boolean);
 	EXPECT_EQ(result, "1");
-	result = Util::format("{:B}", boolean);
+	result = format("{:B}", boolean);
 	EXPECT_EQ(result, "1");
-	result = Util::format("{:d}", boolean);
+	result = format("{:d}", boolean);
 	EXPECT_EQ(result, "1");
-	result = Util::format("{:o}", boolean);
+	result = format("{:o}", boolean);
 	EXPECT_EQ(result, "1");
-	result = Util::format("{:x}", boolean);
+	result = format("{:x}", boolean);
 	EXPECT_EQ(result, "1");
-	result = Util::format("{:X}", boolean);
+	result = format("{:X}", boolean);
 	EXPECT_EQ(result, "1");
 
 	boolean = false;
-	result = Util::format("{:b}", boolean);
+	result = format("{:b}", boolean);
 	EXPECT_EQ(result, "0");
-	result = Util::format("{:B}", boolean);
+	result = format("{:B}", boolean);
 	EXPECT_EQ(result, "0");
-	result = Util::format("{:d}", boolean);
+	result = format("{:d}", boolean);
 	EXPECT_EQ(result, "0");
-	result = Util::format("{:o}", boolean);
+	result = format("{:o}", boolean);
 	EXPECT_EQ(result, "0");
-	result = Util::format("{:x}", boolean);
+	result = format("{:x}", boolean);
 	EXPECT_EQ(result, "0");
-	result = Util::format("{:X}", boolean);
+	result = format("{:X}", boolean);
 	EXPECT_EQ(result, "0");
 }
 
@@ -377,11 +377,11 @@ TEST_CASE(FormatSpecifierString)
 	std::string string = "my string";
 
 	// Fill and Align
-	result = Util::format("{:+<}", string);
+	result = format("{:+<}", string);
 	EXPECT_EQ(result, "my string");
-	result = Util::format("{:+^}", string);
+	result = format("{:+^}", string);
 	EXPECT_EQ(result, "my string");
-	result = Util::format("{:+>}", string);
+	result = format("{:+>}", string);
 	EXPECT_EQ(result, "my string");
 
 	// Sign
@@ -394,22 +394,22 @@ TEST_CASE(FormatSpecifierString)
 	// Not possible on string types
 
 	// Width
-	result = Util::format("{:15}", string);
+	result = format("{:15}", string);
 	EXPECT_EQ(result, "my string      ");
 
 	// Width + Fill and Align
-	result = Util::format("{:+<15}", string);
+	result = format("{:+<15}", string);
 	EXPECT_EQ(result, "my string++++++");
-	result = Util::format("{:+^15}", string);
+	result = format("{:+^15}", string);
 	EXPECT_EQ(result, "+++my string+++");
-	result = Util::format("{:+>15}", string);
+	result = format("{:+>15}", string);
 	EXPECT_EQ(result, "++++++my string");
 
 	// Precision
 	// Not possible on string types
 
 	// Type
-	result = Util::format("{:s}", string);
+	result = format("{:s}", string);
 	EXPECT_EQ(result, "my string");
 }
 
@@ -423,11 +423,11 @@ TEST_CASE(FormatSpecifierPointer)
 	std::string pointer = stream.str();
 
 	// Fill and Align
-	result = Util::format("{:+<}", &integer);
+	result = format("{:+<}", &integer);
 	EXPECT_EQ(result, pointer);
-	result = Util::format("{:+^}", &integer);
+	result = format("{:+^}", &integer);
 	EXPECT_EQ(result, pointer);
-	result = Util::format("{:+>}", &integer);
+	result = format("{:+>}", &integer);
 	EXPECT_EQ(result, pointer);
 
 	// Sign
@@ -440,22 +440,22 @@ TEST_CASE(FormatSpecifierPointer)
 	// Not possible on string types
 
 	// Width
-	result = Util::format("{:24}", &integer);
+	result = format("{:24}", &integer);
 	EXPECT_EQ(result, std::string(24 - pointer.length(), ' ') + pointer);
 
 	// Width + Fill and Align
-	result = Util::format("{:+<24}", &integer);
+	result = format("{:+<24}", &integer);
 	EXPECT_EQ(result, pointer + std::string(24 - pointer.length(), '+'));
-	result = Util::format("{:+^24}", &integer);
+	result = format("{:+^24}", &integer);
 	EXPECT_EQ(result, std::string((24 - pointer.length()) / 2, '+') + pointer + std::string((24 - pointer.length()) / 2, '+'));
-	result = Util::format("{:+>24}", &integer);
+	result = format("{:+>24}", &integer);
 	EXPECT_EQ(result, std::string(24 - pointer.length(), '+') + pointer);
 
 	// Precision
 	// Not possible on string types
 
 	// Type
-	result = Util::format("{:p}", &integer);
+	result = format("{:p}", &integer);
 	EXPECT_EQ(result, pointer);
 }
 
@@ -464,17 +464,17 @@ TEST_CASE(FormatContainers)
 	std::string result;
 
 	std::vector<std::string> vector { "thing1", "thing2", "thing3" };
-	result = Util::format("{}", vector);
+	result = format("{}", vector);
 	EXPECT_EQ(result, "{thing1,thing2,thing3}");
-	result = Util::format("{:1}", vector);
+	result = format("{:1}", vector);
 	EXPECT_EQ(result, "{ thing1, thing2, thing3 }");
-	result = Util::format("{:#4}", vector);
+	result = format("{:#4}", vector);
 	EXPECT_EQ(result, R"({
     thing1,
     thing2,
     thing3
 })");
-	result = Util::format("{:\t<#1}", vector);
+	result = format("{:\t<#1}", vector);
 	EXPECT_EQ(result, R"({
 	thing1,
 	thing2,
@@ -482,17 +482,17 @@ TEST_CASE(FormatContainers)
 })");
 
 	std::map<std::string, int> map { { "thing3", 3 }, { "thing2", 2 }, { "thing1", 1 } };
-	result = Util::format("{}", map);
+	result = format("{}", map);
 	EXPECT_EQ(result, R"({"thing1":1,"thing2":2,"thing3":3})");
-	result = Util::format("{:1}", map);
+	result = format("{:1}", map);
 	EXPECT_EQ(result, R"({ "thing1": 1, "thing2": 2, "thing3": 3 })");
-	result = Util::format("{:#4}", map);
+	result = format("{:#4}", map);
 	EXPECT_EQ(result, R"({
     "thing1": 1,
     "thing2": 2,
     "thing3": 3
 })");
-	result = Util::format("{:\t<#1}", map);
+	result = format("{:\t<#1}", map);
 	EXPECT_EQ(result, R"({
 	"thing1": 1,
 	"thing2": 2,
@@ -505,7 +505,7 @@ TEST_CASE(FormatContainers)
 		{ "thing1", "thing2", "thing3" },
 		{ "thing1", "thing2", "thing3" }
 	};
-	result = Util::format("{:#4}", twoDimensionalVector);
+	result = format("{:#4}", twoDimensionalVector);
 	EXPECT_EQ(result, R"({
     {thing1,thing2,thing3},
     {thing1,thing2,thing3}

test/unit/testutiljson.cpp

@@ -13,40 +13,40 @@
 #include <vector>
 
 #include "macro.h"
+#include "ruc/json/array.h"
+#include "ruc/json/job.h"
+#include "ruc/json/json.h"
+#include "ruc/json/lexer.h"
+#include "ruc/json/parser.h"
+#include "ruc/json/serializer.h"
 #include "testcase.h"
 #include "testsuite.h"
-#include "util/json/array.h"
-#include "util/json/job.h"
-#include "util/json/json.h"
-#include "util/json/lexer.h"
-#include "util/json/parser.h"
-#include "util/json/serializer.h"
 
 #define DONT_PRINT_PARSER_ERRORS
 
 #ifndef DONT_PRINT_PARSER_ERRORS
-#define EXEC(x) x
+	#define EXEC(x) x
 #else
-#define EXEC(x)                                   \
-	stderr = Test::TestSuite::the().outputNull(); \
-	x;                                            \
-	stderr = Test::TestSuite::the().outputErr();
+	#define EXEC(x)                                   \
+		stderr = test::TestSuite::the().outputNull(); \
+		x;                                            \
+		stderr = test::TestSuite::the().outputErr();
 #endif
 
-std::vector<Util::JSON::Token> lex(const std::string& input)
+std::vector<ruc::json::Token> lex(const std::string& input)
 {
 	EXEC(
-		Util::JSON::Job job(input);
-		Util::JSON::Lexer lexer(&job);
+		ruc::json::Job job(input);
+		ruc::json::Lexer lexer(&job);
 		lexer.analyze(););
 	return *job.tokens();
 }
 
-Util::Json parse(const std::string& input)
+ruc::Json parse(const std::string& input)
 {
 	EXEC(
-		Util::JSON::Job job(input);
-		Util::JSON::Lexer lexer(&job);
+		ruc::json::Job job(input);
+		ruc::json::Lexer lexer(&job);
 		lexer.analyze(););
 
 	if (!job.success()) {
@@ -54,8 +54,8 @@ Util::Json parse(const std::string& input)
 	}
 
 	EXEC(
-		Util::JSON::Parser parser(&job);
-		Util::Json json = parser.parse(););
+		ruc::json::Parser parser(&job);
+		ruc::Json json = parser.parse(););
 
 	if (!job.success()) {
 		return nullptr;
@@ -67,7 +67,7 @@ Util::Json parse(const std::string& input)
 std::string serialize(const std::string& input, uint32_t indent = 0)
 {
 	EXEC(
-		auto json = Util::Json::parse(input););
+		auto json = ruc::Json::parse(input););
 	return json.dump(indent);
 }
 
@@ -75,59 +75,59 @@ std::string serialize(const std::string& input, uint32_t indent = 0)
 
 TEST_CASE(JsonLexer)
 {
-	std::vector<Util::JSON::Token> tokens;
+	std::vector<ruc::json::Token> tokens;
 
 	// Literal
 
 	tokens = lex("true");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "true");
-	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
+	EXPECT(tokens[0].type == ruc::json::Token::Type::Literal);
 
 	tokens = lex("false");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "false");
-	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
+	EXPECT(tokens[0].type == ruc::json::Token::Type::Literal);
 
 	tokens = lex("null");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "null");
-	EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
+	EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Number);
+	EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Number);
+	EXPECT(tokens[0].type == ruc::json::Token::Type::Number);
 
 	tokens = lex("+3.14");
 	EXPECT_EQ(tokens.size(), 1);
 	EXPECT_EQ(tokens[0].symbol, "+");
-	EXPECT(tokens[0].type == Util::JSON::Token::Type::None);
+	EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String);
+	EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String);
+	EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String);
+	EXPECT(tokens[0].type == ruc::json::Token::Type::String);
 
 	// Array
 
@@ -156,186 +156,186 @@ TEST_CASE(JsonLexer)
 
 TEST_CASE(JsonParser)
 {
-	Util::Json json;
+	ruc::Json json;
 
 	json = parse("null");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("true");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
 
 	json = parse("false");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
 
 	json = parse("3.14");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Number);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Number);
 
 	json = parse(R"("a string")");
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::String);
+	EXPECT_EQ(json.type(), ruc::Json::Type::String);
 
 	// Array
 
 	json = parse("[");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("[ 123");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("[ 123,");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("[ 123, ]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("[ 123 456 ]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("[]");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Array);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Array);
 
 	json = parse(R"([ "element", 3.14 ])");
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Util::Json::Type::Array);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Array);
 
 	// Object
 
 	json = parse("{");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name")");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name":)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name":,)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name":"value")");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name":"value",)");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name":"value", })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ "name" "value" })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse(R"({ 123 })");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("{}");
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Object);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Object);
 
 	json = parse(R"({ "name": "value", "name2": 3.14 })");
 	EXPECT_EQ(json.size(), 2);
-	EXPECT_EQ(json.type(), Util::Json::Type::Object);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Object);
 
 	// Multiple root elements
 
 	json = parse("54 false");
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("3.14, 666");
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = parse("true\nfalse");
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 }
 
 TEST_CASE(JsonToJsonValue)
 {
-	Util::Json json;
+	ruc::Json json;
 
 	json = {};
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = nullptr;
 	EXPECT_EQ(json.size(), 0);
-	EXPECT_EQ(json.type(), Util::Json::Type::Null);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Null);
 
 	json = true;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
 
 	json = false;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Bool);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
 
 	json = 666;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Number);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Number);
 
 	json = 3.14;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::Number);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Number);
 
 	const char* characters = "my string";
 	json = characters;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::String);
+	EXPECT_EQ(json.type(), ruc::Json::Type::String);
 
 	std::string string = "my string";
 	json = string;
 	EXPECT_EQ(json.size(), 1);
-	EXPECT_EQ(json.type(), Util::Json::Type::String);
+	EXPECT_EQ(json.type(), ruc::Json::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(), Util::Json::Type::Array);
+	EXPECT_EQ(json.type(), ruc::Json::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(), Util::Json::Type::Object);
+	EXPECT_EQ(json.type(), ruc::Json::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(), Util::Json::Type::Array);
+	EXPECT_EQ(json.type(), ruc::Json::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(), Util::Json::Type::Object);
+	EXPECT_EQ(json.type(), ruc::Json::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(), Util::Json::Type::Object);
+	EXPECT_EQ(json.type(), ruc::Json::Type::Object);
 }
 
 TEST_CASE(JsonFromJsonValue)
 {
-	Util::Json json;
+	ruc::Json json;
 
 	json = nullptr;
 	EXPECT_EQ(json.get<std::nullptr_t>(), nullptr);
@@ -373,7 +373,7 @@ TEST_CASE(JsonFromJsonValue)
 	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<Util::Json>>();
+	auto valueArray = json.get<std::vector<ruc::Json>>();
 	EXPECT_EQ(valueArray.size(), 4);
 	EXPECT_EQ(valueArray[0].get<std::string>(), "string");
 	EXPECT_EQ(valueArray[1].get<double>(), 3.14);
@@ -417,7 +417,7 @@ TEST_CASE(JsonFromJsonValue)
 	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, Util::Json>>();
+	auto valueObject = json.get<std::map<std::string, ruc::Json>>();
 	EXPECT_EQ(valueObject.size(), 4);
 	EXPECT_EQ(valueObject["name"].get<std::string>(), "value");
 	EXPECT_EQ(valueObject["name2"].get<double>(), 3.14);
@@ -455,25 +455,25 @@ TEST_CASE(JsonFromJsonValue)
 
 TEST_CASE(JsonImplicitConversion)
 {
-	Util::Json array;
+	ruc::Json array;
 	array[0];
-	EXPECT_EQ(array.type(), Util::Json::Type::Array);
+	EXPECT_EQ(array.type(), ruc::Json::Type::Array);
 
-	Util::Json arrayEmplace;
+	ruc::Json arrayEmplace;
 	arrayEmplace.emplace_back("element");
 	arrayEmplace.emplace_back({ "nested element" });
-	EXPECT_EQ(arrayEmplace.type(), Util::Json::Type::Array);
-	EXPECT_EQ(arrayEmplace[1].type(), Util::Json::Type::Array);
+	EXPECT_EQ(arrayEmplace.type(), ruc::Json::Type::Array);
+	EXPECT_EQ(arrayEmplace[1].type(), ruc::Json::Type::Array);
 
-	Util::Json object;
+	ruc::Json object;
 	object[""];
-	EXPECT_EQ(object.type(), Util::Json::Type::Object);
+	EXPECT_EQ(object.type(), ruc::Json::Type::Object);
 
-	Util::Json objectEmplace;
+	ruc::Json objectEmplace;
 	objectEmplace.emplace("name", "value");
 	objectEmplace.emplace("name2", { { "nested name", "value" } });
-	EXPECT_EQ(objectEmplace.type(), Util::Json::Type::Object);
-	EXPECT_EQ(objectEmplace["name2"].type(), Util::Json::Type::Object);
+	EXPECT_EQ(objectEmplace.type(), ruc::Json::Type::Object);
+	EXPECT_EQ(objectEmplace["name2"].type(), ruc::Json::Type::Object);
 }
 
 TEST_CASE(JsonSerializer)

test/unit/testutilshell.cpp

@@ -1,21 +1,21 @@
 #include <string>
 
 #include "macro.h"
+#include "ruc/shell.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();
+	stdout = test::TestSuite::the().outputNull();
 
-	Util::Shell $;
+	ruc::Shell $;
 	auto exec = $(command);
 	if (output) {
 		*output = exec.output();
 	}
 
-	stdout = Test::TestSuite::the().outputStd();
+	stdout = test::TestSuite::the().outputStd();
 	return !exec.status() ? true : false;
 }
 

test/unit/testutilsystem.cpp

@@ -3,13 +3,13 @@
 #include <vector>
 
 #include "macro.h"
+#include "ruc/system.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)
+bool runSystem(std::function<ruc::System(ruc::System&)> commands, std::string* output = nullptr, std::string* error = nullptr)
 {
-	Util::System system;
+	ruc::System system;
 	auto exec = commands(system);
 	if (output) {
 		*output = exec.output();
@@ -30,7 +30,8 @@ TEST_CASE(SystemCommand)
 	std::string error = "";
 	auto result = runSystem([&](auto& $) {
 		return $("echo Hello World!")();
-	}, &output, &error);
+	},
+	                        &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "Hello World!\n");
 	EXPECT_EQ(error, "");
@@ -40,7 +41,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return $("echo -n Hello ") + $("echo -n World!");
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "Hello World!");
 	EXPECT_EQ(error, "");
@@ -50,7 +52,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return $("echo Hello World!") | $("grep --only-matching Hello");
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "Hello\n");
 	EXPECT_EQ(error, "");
@@ -60,7 +63,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return $("echo Hello") && $("echo World!");
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "Hello\nWorld!\n");
 	EXPECT_EQ(error, "");
@@ -70,7 +74,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return $("echo Hello") || $("echo World!");
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "Hello\n");
 	EXPECT_EQ(error, "");
@@ -80,7 +85,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return ($("echo -n one ") && $("echo -n two ") && $("echo -n three")) | $("grep --only-matching two");
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, true);
 	EXPECT_EQ(output, "two\n");
 	EXPECT_EQ(error, "");
@@ -91,7 +97,8 @@ TEST_CASE(SystemCommand)
 	error = "";
 	result = runSystem([&](auto& $) {
 		return $("exit 1")();
-	}, &output, &error);
+	},
+	                   &output, &error);
 	EXPECT_EQ(result, false);
 	EXPECT_EQ(output, "");
 	EXPECT_EQ(error, "");