diff irccdctl/cli.cpp @ 773:8c44bbcbbab9

Misc: style, cleanup and update
author David Demelier <markand@malikania.fr>
date Fri, 26 Oct 2018 13:01:00 +0200
parents 445c071e8efb
children 7145a3df4cb7
line wrap: on
line diff
--- a/irccdctl/cli.cpp	Wed Oct 24 13:24:03 2018 +0200
+++ b/irccdctl/cli.cpp	Fri Oct 26 13:01:00 2018 +0200
@@ -28,6 +28,8 @@
 
 #include "cli.hpp"
 
+using irccd::json_util::deserializer;
+
 namespace irccd::ctl {
 
 // {{{ helpers
@@ -37,192 +39,192 @@
 template <typename T>
 auto bind() noexcept -> cli::constructor
 {
-    return [] () noexcept {
-        return std::make_unique<T>();
-    };
+	return [] () noexcept {
+		return std::make_unique<T>();
+	};
 }
 
 auto format(std::vector<std::string> args) -> std::string
 {
-    auto result = option::read(args, {
-        { "-f",         true },
-        { "--format",   true }
-    });
+	auto result = option::read(args, {
+		{ "-f",         true },
+		{ "--format",   true }
+	});
 
-    if (result.count("-f") > 0)
-        return result.find("-f")->second;
-    if (result.count("--format") > 0)
-        return result.find("--format")->second;
+	if (result.count("-f") > 0)
+		return result.find("-f")->second;
+	if (result.count("--format") > 0)
+		return result.find("--format")->second;
 
-    return "native";
+	return "native";
 }
 
 void onConnect(const nlohmann::json &v)
 {
-    std::cout << "event:       onConnect\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "event:    onConnect\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
 }
 
 void onInvite(const nlohmann::json &v)
 {
-    std::cout << "event:       onInvite\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "event:    onInvite\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
 }
 
 void onJoin(const nlohmann::json &v)
 {
-    std::cout << "event:       onJoin\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "event:    onJoin\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
 }
 
 void onKick(const nlohmann::json &v)
 {
-    std::cout << "event:       onKick\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
-    std::cout << "target:      " << json_util::pretty(v.value("target", "(unknown)")) << "\n";
-    std::cout << "reason:      " << json_util::pretty(v.value("reason", "(unknown)")) << "\n";
+	std::cout << "event:    onKick\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "target:   " << json_util::pretty(v.value("target", "(unknown)")) << "\n";
+	std::cout << "reason:   " << json_util::pretty(v.value("reason", "(unknown)")) << "\n";
 }
 
 void onMessage(const nlohmann::json &v)
 {
-    std::cout << "event:       onMessage\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
-    std::cout << "message:     " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
+	std::cout << "event:    onMessage\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "message:  " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
 }
 
 void onMe(const nlohmann::json &v)
 {
-    std::cout << "event:       onMe\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "target:      " << json_util::pretty(v.value("target", "(unknown)")) << "\n";
-    std::cout << "message:     " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
+	std::cout << "event:    onMe\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "target:   " << json_util::pretty(v.value("target", "(unknown)")) << "\n";
+	std::cout << "message:  " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
 }
 
 void onMode(const nlohmann::json &v)
 {
-    std::cout << "event:       onMode\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "mode:        " << json_util::pretty(v.value("mode", "(unknown)")) << "\n";
+	std::cout << "event:    onMode\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "mode:     " << json_util::pretty(v.value("mode", "(unknown)")) << "\n";
 }
 
 void onNames(const nlohmann::json &v)
 {
-    std::cout << "event:       onNames\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
-    std::cout << "names:       " << json_util::pretty(v.value("names", "(unknown)")) << "\n";
+	std::cout << "event:    onNames\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "names:    " << json_util::pretty(v.value("names", "(unknown)")) << "\n";
 }
 
 void onNick(const nlohmann::json &v)
 {
-    std::cout << "event:       onNick\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "nickname:    " << json_util::pretty(v.value("nickname", "(unknown)")) << "\n";
+	std::cout << "event:    onNick\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "nickname: " << json_util::pretty(v.value("nickname", "(unknown)")) << "\n";
 }
 
 void onNotice(const nlohmann::json &v)
 {
-    std::cout << "event:       onNotice\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "message:     " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
+	std::cout << "event:    onNotice\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "message:  " << json_util::pretty(v.value("message", "(unknown)")) << "\n";
 }
 
 void onPart(const nlohmann::json &v)
 {
-    std::cout << "event:       onPart\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
-    std::cout << "reason:      " << json_util::pretty(v.value("reason", "(unknown)")) << "\n";
+	std::cout << "event:    onPart\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "reason:   " << json_util::pretty(v.value("reason", "(unknown)")) << "\n";
 }
 
 void onTopic(const nlohmann::json &v)
 {
-    std::cout << "event:       onTopic\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "origin:      " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
-    std::cout << "channel:     " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
-    std::cout << "topic:       " << json_util::pretty(v.value("topic", "(unknown)")) << "\n";
+	std::cout << "event:    onTopic\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "origin:   " << json_util::pretty(v.value("origin", "(unknown)")) << "\n";
+	std::cout << "channel:  " << json_util::pretty(v.value("channel", "(unknown)")) << "\n";
+	std::cout << "topic:    " << json_util::pretty(v.value("topic", "(unknown)")) << "\n";
 }
 
 void onWhois(const nlohmann::json &v)
 {
-    std::cout << "event:       onWhois\n";
-    std::cout << "server:      " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
-    std::cout << "nickname:    " << json_util::pretty(v.value("nickname", "(unknown)")) << "\n";
-    std::cout << "username:    " << json_util::pretty(v.value("username", "(unknown)")) << "\n";
-    std::cout << "host:        " << json_util::pretty(v.value("host", "(unknown)")) << "\n";
-    std::cout << "realname:    " << json_util::pretty(v.value("realname", "(unknown)")) << "\n";
+	std::cout << "event:    onWhois\n";
+	std::cout << "server:   " << json_util::pretty(v.value("server", "(unknown)")) << "\n";
+	std::cout << "nickname: " << json_util::pretty(v.value("nickname", "(unknown)")) << "\n";
+	std::cout << "username: " << json_util::pretty(v.value("username", "(unknown)")) << "\n";
+	std::cout << "host:     " << json_util::pretty(v.value("host", "(unknown)")) << "\n";
+	std::cout << "realname: " << json_util::pretty(v.value("realname", "(unknown)")) << "\n";
 }
 
 const std::unordered_map<std::string_view, std::function<void (const nlohmann::json&)>> events{
-    { "onConnect",          onConnect       },
-    { "onInvite",           onInvite        },
-    { "onJoin",             onJoin          },
-    { "onKick",             onKick          },
-    { "onMessage",          onMessage       },
-    { "onMe",               onMe            },
-    { "onMode",             onMode          },
-    { "onNames",            onNames         },
-    { "onNick",             onNick          },
-    { "onNotice",           onNotice        },
-    { "onPart",             onPart          },
-    { "onTopic",            onTopic         },
-    { "onWhois",            onWhois         }
+	{ "onConnect",  onConnect       },
+	{ "onInvite",   onInvite        },
+	{ "onJoin",     onJoin          },
+	{ "onKick",     onKick          },
+	{ "onMessage",  onMessage       },
+	{ "onMe",       onMe            },
+	{ "onMode",     onMode          },
+	{ "onNames",    onNames         },
+	{ "onNick",     onNick          },
+	{ "onNotice",   onNotice        },
+	{ "onPart",     onPart          },
+	{ "onTopic",    onTopic         },
+	{ "onWhois",    onWhois         }
 };
 
 void get_event(ctl::controller& ctl, std::string fmt)
 {
-    ctl.read([&ctl, fmt] (auto code, auto message) {
-        if (code)
-            throw std::system_error(code);
+	ctl.read([&ctl, fmt] (auto code, auto message) {
+		if (code)
+			throw std::system_error(code);
 
-        const auto event = json_util::document(message).get<std::string>("event");
-        const auto it = events.find(event ? *event : "");
+		const auto event = deserializer(message).get<std::string>("event");
+		const auto it = events.find(event ? *event : "");
 
-        if (it != events.end()) {
-            if (fmt == "json")
-                std::cout << message.dump(4) << std::endl;
-            else {
-                it->second(message);
-                std::cout << std::endl;
-            }
-        }
+		if (it != events.end()) {
+			if (fmt == "json")
+				std::cout << message.dump(4) << std::endl;
+			else {
+				it->second(message);
+				std::cout << std::endl;
+			}
+		}
 
-        get_event(ctl, std::move(fmt));
-    });
+		get_event(ctl, std::move(fmt));
+	});
 }
 
 auto parse(std::vector<std::string> &args) -> option::result
 {
-    option::options options{
-        { "-c",             true    },
-        { "--command",      true    },
-        { "-n",             true    },
-        { "--nickname",     true    },
-        { "-r",             true    },
-        { "--realname",     true    },
-        { "-S",             false   },
-        { "--ssl-verify",   false   },
-        { "-s",             false   },
-        { "--ssl",          false   },
-        { "-u",             true    },
-        { "--username",     true    }
-    };
+	option::options options{
+		{ "-c",                 true    },
+		{ "--command",          true    },
+		{ "-n",                 true    },
+		{ "--nickname",         true    },
+		{ "-r",                 true    },
+		{ "--realname",         true    },
+		{ "-S",                 false   },
+		{ "--ssl-verify",       false   },
+		{ "-s",                 false   },
+		{ "--ssl",              false   },
+		{ "-u",                 true    },
+		{ "--username",         true    }
+	};
 
-    return option::read(args, options);
+	return option::read(args, options);
 }
 
 } // !namespace
@@ -232,63 +234,62 @@
 // {{{ cli
 
 const std::vector<cli::constructor> cli::registry{
-    bind<plugin_config_cli>(),
-    bind<plugin_info_cli>(),
-    bind<plugin_list_cli>(),
-    bind<plugin_load_cli>(),
-    bind<plugin_reload_cli>(),
-    bind<plugin_unload_cli>(),
-    bind<rule_add_cli>(),
-    bind<rule_edit_cli>(),
-    bind<rule_info_cli>(),
-    bind<rule_info_cli>(),
-    bind<rule_list_cli>(),
-    bind<rule_move_cli>(),
-    bind<rule_remove_cli>(),
-    bind<server_connect_cli>(),
-    bind<server_disconnect_cli>(),
-    bind<server_info_cli>(),
-    bind<server_invite_cli>(),
-    bind<server_join_cli>(),
-    bind<server_kick_cli>(),
-    bind<server_list_cli>(),
-    bind<server_me_cli>(),
-    bind<server_message_cli>(),
-    bind<server_mode_cli>(),
-    bind<server_nick_cli>(),
-    bind<server_notice_cli>(),
-    bind<server_part_cli>(),
-    bind<server_reconnect_cli>(),
-    bind<server_topic_cli>(),
-    bind<watch_cli>()
+	bind<plugin_config_cli>(),
+	bind<plugin_info_cli>(),
+	bind<plugin_list_cli>(),
+	bind<plugin_load_cli>(),
+	bind<plugin_reload_cli>(),
+	bind<plugin_unload_cli>(),
+	bind<rule_add_cli>(),
+	bind<rule_edit_cli>(),
+	bind<rule_info_cli>(),
+	bind<rule_list_cli>(),
+	bind<rule_move_cli>(),
+	bind<rule_remove_cli>(),
+	bind<server_connect_cli>(),
+	bind<server_disconnect_cli>(),
+	bind<server_info_cli>(),
+	bind<server_invite_cli>(),
+	bind<server_join_cli>(),
+	bind<server_kick_cli>(),
+	bind<server_list_cli>(),
+	bind<server_me_cli>(),
+	bind<server_message_cli>(),
+	bind<server_mode_cli>(),
+	bind<server_nick_cli>(),
+	bind<server_notice_cli>(),
+	bind<server_part_cli>(),
+	bind<server_reconnect_cli>(),
+	bind<server_topic_cli>(),
+	bind<watch_cli>()
 };
 
 void cli::recv_response(ctl::controller& ctl, nlohmann::json req, handler_t handler)
 {
-    ctl.read([&ctl, req, handler, this] (auto code, auto message) {
-        if (code)
-            throw std::system_error(code);
+	ctl.read([&ctl, req, handler, this] (auto code, auto message) {
+		if (code)
+			throw std::system_error(code);
 
-        const auto c = json_util::document(message).get<std::string>("command");
+		const auto c = deserializer(message).get<std::string>("command");
 
-        if (!c) {
-            recv_response(ctl, std::move(req), std::move(handler));
-            return;
-        }
+		if (!c) {
+			recv_response(ctl, std::move(req), std::move(handler));
+			return;
+		}
 
-        if (handler)
-            handler(std::move(message));
-    });
+		if (handler)
+			handler(std::move(message));
+	});
 }
 
 void cli::request(ctl::controller& ctl, nlohmann::json req, handler_t handler)
 {
-    ctl.write(req, [&ctl, req, handler, this] (auto code) {
-        if (code)
-            throw std::system_error(code);
+	ctl.write(req, [&ctl, req, handler, this] (auto code) {
+		if (code)
+			throw std::system_error(code);
 
-        recv_response(ctl, std::move(req), std::move(handler));
-    });
+		recv_response(ctl, std::move(req), std::move(handler));
+	});
 }
 
 // }}}
@@ -297,63 +298,63 @@
 
 void plugin_config_cli::set(ctl::controller& ctl, const std::vector<std::string>&args)
 {
-    request(ctl, {
-        { "command",    "plugin-config" },
-        { "plugin",     args[0]         },
-        { "variable",   args[1]         },
-        { "value",      args[2]         }
-    });
+	request(ctl, {
+		{ "command",    "plugin-config" },
+		{ "plugin",     args[0]         },
+		{ "variable",   args[1]         },
+		{ "value",      args[2]         }
+	});
 }
 
 void plugin_config_cli::get(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    auto json = nlohmann::json::object({
-        { "command",    "plugin-config" },
-        { "plugin",     args[0]         },
-        { "variable",   args[1]         }
-    });
+	auto json = nlohmann::json::object({
+		{ "command",    "plugin-config" },
+		{ "plugin",     args[0]         },
+		{ "variable",   args[1]         }
+	});
 
-    request(ctl, std::move(json), [args] (auto result) {
-        if (result["variables"].is_object())
-            std::cout << json_util::pretty(result["variables"][args[1]]) << std::endl;
-    });
+	request(ctl, std::move(json), [args] (auto result) {
+		if (result["variables"].is_object())
+			std::cout << json_util::pretty(result["variables"][args[1]]) << std::endl;
+	});
 }
 
 void plugin_config_cli::getall(ctl::controller& ctl, const std::vector<std::string> &args)
 {
-    const auto json = nlohmann::json::object({
-        { "command",    "plugin-config" },
-        { "plugin",     args[0]         }
-    });
+	const auto json = nlohmann::json::object({
+		{ "command",    "plugin-config" },
+		{ "plugin",     args[0]         }
+	});
 
-    request(ctl, json, [] (auto result) {
-        const auto variables = result["variables"];
+	request(ctl, json, [] (auto result) {
+		const auto variables = result["variables"];
 
-        for (auto v = variables.begin(); v != variables.end(); ++v)
-            std::cout << std::setw(16) << std::left << v.key() << " : " << json_util::pretty(v.value()) << std::endl;
-    });
+		for (auto v = variables.begin(); v != variables.end(); ++v)
+			std::cout << std::setw(16) << std::left << v.key() << " : " << json_util::pretty(v.value()) << std::endl;
+	});
 }
 
 auto plugin_config_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-config";
+	return "plugin-config";
 }
 
 void plugin_config_cli::exec(ctl::controller& ctl, const std::vector<std::string> &args)
 {
-    switch (args.size()) {
-    case 3:
-        set(ctl, args);
-        break;
-    case 2:
-        get(ctl, args);
-        break;
-    case 1:
-        getall(ctl, args);
-        break;
-    default:
-        throw std::invalid_argument("plugin-config requires at least 1 argument");
-    }
+	switch (args.size()) {
+	case 3:
+		set(ctl, args);
+		break;
+	case 2:
+		get(ctl, args);
+		break;
+	case 1:
+		getall(ctl, args);
+		break;
+	default:
+		throw std::invalid_argument("plugin-config requires at least 1 argument");
+	}
 }
 
 // }}}
@@ -362,32 +363,32 @@
 
 auto plugin_info_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-info";
+	return "plugin-info";
 }
 
 void plugin_info_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("plugin-info requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("plugin-info requires 1 argument");
 
-    const auto json = nlohmann::json::object({
-        { "command",    "plugin-info"   },
-        { "plugin",     args[0]         }
-    });
+	const auto json = nlohmann::json::object({
+		{ "command",    "plugin-info"   },
+		{ "plugin",     args[0]         }
+	});
 
-    request(ctl, json, [] (auto result) {
-        const json_util::document doc(result);
+	request(ctl, json, [] (auto result) {
+		const deserializer doc(result);
 
-        std::cout << std::boolalpha;
-        std::cout << "Author         : " <<
-            doc.get<std::string>("author").value_or("(unknown)") << std::endl;
-        std::cout << "License        : " <<
-            doc.get<std::string>("license").value_or("(unknown)") << std::endl;
-        std::cout << "Summary        : " <<
-            doc.get<std::string>("summary").value_or("(unknown)") << std::endl;
-        std::cout << "Version        : " <<
-            doc.get<std::string>("version").value_or("(unknown)") << std::endl;
-    });
+		std::cout << std::boolalpha;
+		std::cout << "Author         : "
+		          << doc.get<std::string>("author").value_or("(unknown)") << std::endl;
+		std::cout << "License        : "
+		          << doc.get<std::string>("license").value_or("(unknown)") << std::endl;
+		std::cout << "Summary        : "
+		          << doc.get<std::string>("summary").value_or("(unknown)") << std::endl;
+		std::cout << "Version        : "
+		          << doc.get<std::string>("version").value_or("(unknown)") << std::endl;
+	});
 }
 
 // }}}
@@ -396,16 +397,16 @@
 
 auto plugin_list_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-list";
+	return "plugin-list";
 }
 
 void plugin_list_cli::exec(ctl::controller& ctl, const std::vector<std::string>&)
 {
-    request(ctl, {{ "command", "plugin-list" }}, [] (auto result) {
-        for (const auto& value : result["list"])
-            if (value.is_string())
-                std::cout << value.template get<std::string>() << std::endl;
-    });
+	request(ctl, {{ "command", "plugin-list" }}, [] (auto result) {
+		for (const auto& value : result["list"])
+			if (value.is_string())
+				std::cout << value.template get<std::string>() << std::endl;
+	});
 }
 
 // }}}
@@ -414,18 +415,18 @@
 
 auto plugin_load_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-load";
+	return "plugin-load";
 }
 
 void plugin_load_cli::exec(ctl::controller& ctl, const std::vector<std::string> &args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("plugin-load requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("plugin-load requires 1 argument");
 
-    request(ctl, {
-        { "command",    "plugin-load"   },
-        { "plugin",     args[0]         }
-    });
+	request(ctl, {
+		{ "command",    "plugin-load"   },
+		{ "plugin",     args[0]         }
+	});
 }
 
 // }}}
@@ -434,18 +435,18 @@
 
 auto plugin_reload_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-reload";
+	return "plugin-reload";
 }
 
 void plugin_reload_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("plugin-reload requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("plugin-reload requires 1 argument");
 
-    request(ctl, {
-        { "command",    "plugin-reload" },
-        { "plugin",     args[0]         }
-    });
+	request(ctl, {
+		{ "command",    "plugin-reload" },
+		{ "plugin",     args[0]         }
+	});
 }
 
 // }}}
@@ -454,18 +455,18 @@
 
 auto plugin_unload_cli::get_name() const noexcept -> std::string_view
 {
-    return "plugin-unload";
+	return "plugin-unload";
 }
 
 void plugin_unload_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("plugin-unload requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("plugin-unload requires 1 argument");
 
-    request(ctl, {
-        { "command",    "plugin-unload" },
-        { "plugin",     args[0]         }
-    });
+	request(ctl, {
+		{ "command",    "plugin-unload" },
+		{ "plugin",     args[0]         }
+	});
 }
 
 // }}}
@@ -474,64 +475,64 @@
 
 auto rule_add_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-add";
+	return "rule-add";
 }
 
 void rule_add_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    static const option::options options{
-        { "-c",             true },
-        { "--add-channel",  true },
-        { "-e",             true },
-        { "--add-event",    true },
-        { "-i",             true },
-        { "--index",        true },
-        { "-p",             true },
-        { "--add-plugin",   true },
-        { "-s",             true },
-        { "--add-server",   true }
-    };
+	static const option::options options{
+		{ "-c",                 true },
+		{ "--add-channel",      true },
+		{ "-e",                 true },
+		{ "--add-event",        true },
+		{ "-i",                 true },
+		{ "--index",            true },
+		{ "-p",                 true },
+		{ "--add-plugin",       true },
+		{ "-s",                 true },
+		{ "--add-server",       true }
+	};
 
-    auto copy = args;
-    auto result = option::read(copy, options);
+	auto copy = args;
+	auto result = option::read(copy, options);
 
-    if (copy.size() < 1)
-        throw std::invalid_argument("rule-add requires at least 1 argument");
+	if (copy.size() < 1)
+		throw std::invalid_argument("rule-add requires at least 1 argument");
 
-    auto json = nlohmann::json::object({
-        { "command",    "rule-add"              },
-        { "channels",   nlohmann::json::array() },
-        { "events",     nlohmann::json::array() },
-        { "plugins",    nlohmann::json::array() },
-        { "servers",    nlohmann::json::array() }
-    });
+	auto json = nlohmann::json::object({
+		{ "command",    "rule-add"              },
+		{ "channels",   nlohmann::json::array() },
+		{ "events",     nlohmann::json::array() },
+		{ "plugins",    nlohmann::json::array() },
+		{ "servers",    nlohmann::json::array() }
+	});
 
-    // All sets.
-    for (const auto& pair : result) {
-        if (pair.first == "-c" || pair.first == "--add-channel")
-            json["channels"].push_back(pair.second);
-        if (pair.first == "-e" || pair.first == "--add-event")
-            json["events"].push_back(pair.second);
-        if (pair.first == "-p" || pair.first == "--add-plugin")
-            json["plugins"].push_back(pair.second);
-        if (pair.first == "-s" || pair.first == "--add-server")
-            json["servers"].push_back(pair.second);
-    }
+	// All sets.
+	for (const auto& pair : result) {
+		if (pair.first == "-c" || pair.first == "--add-channel")
+			json["channels"].push_back(pair.second);
+		if (pair.first == "-e" || pair.first == "--add-event")
+			json["events"].push_back(pair.second);
+		if (pair.first == "-p" || pair.first == "--add-plugin")
+			json["plugins"].push_back(pair.second);
+		if (pair.first == "-s" || pair.first == "--add-server")
+			json["servers"].push_back(pair.second);
+	}
 
-    // Index.
-    std::optional<unsigned> index;
+	// Index.
+	std::optional<unsigned> index;
 
-    if (result.count("-i") > 0 && !(index = string_util::to_uint(result.find("-i")->second)))
-        throw std::invalid_argument("invalid index argument");
-    if (result.count("--index") > 0 && !(index = string_util::to_uint(result.find("--index")->second)))
-        throw std::invalid_argument("invalid index argument");
+	if (result.count("-i") > 0 && !(index = string_util::to_uint(result.find("-i")->second)))
+		throw std::invalid_argument("invalid index argument");
+	if (result.count("--index") > 0 && !(index = string_util::to_uint(result.find("--index")->second)))
+		throw std::invalid_argument("invalid index argument");
 
-    if (index)
-        json["index"] = *index;
+	if (index)
+		json["index"] = *index;
 
-    json["action"] = copy[0];
+	json["action"] = copy[0];
 
-    request(ctl, json);
+	request(ctl, json);
 }
 
 // }}}
@@ -540,81 +541,81 @@
 
 auto rule_edit_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-edit";
+	return "rule-edit";
 }
 
 void rule_edit_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    static const option::options options{
-        { "-a",                 true },
-        { "--action",           true },
-        { "-c",                 true },
-        { "--add-channel",      true },
-        { "-C",                 true },
-        { "--remove-channel",   true },
-        { "-e",                 true },
-        { "--add-event",        true },
-        { "-E",                 true },
-        { "--remove-event",     true },
-        { "-p",                 true },
-        { "--add-plugin",       true },
-        { "-P",                 true },
-        { "--remove-plugin",    true },
-        { "-s",                 true },
-        { "--add-server",       true },
-        { "-S",                 true },
-        { "--remove-server",    true },
-    };
+	static const option::options options{
+		{ "-a",                 true },
+		{ "--action",           true },
+		{ "-c",                 true },
+		{ "--add-channel",      true },
+		{ "-C",                 true },
+		{ "--remove-channel",   true },
+		{ "-e",                 true },
+		{ "--add-event",        true },
+		{ "-E",                 true },
+		{ "--remove-event",     true },
+		{ "-p",                 true },
+		{ "--add-plugin",       true },
+		{ "-P",                 true },
+		{ "--remove-plugin",    true },
+		{ "-s",                 true },
+		{ "--add-server",       true },
+		{ "-S",                 true },
+		{ "--remove-server",    true },
+	};
 
-    auto copy = args;
-    auto result = option::read(copy, options);
+	auto copy = args;
+	auto result = option::read(copy, options);
 
-    if (copy.size() < 1)
-        throw std::invalid_argument("rule-edit requires at least 1 argument");
+	if (copy.size() < 1)
+		throw std::invalid_argument("rule-edit requires at least 1 argument");
 
-    auto json = nlohmann::json::object({
-        { "command",    "rule-edit"             },
-        { "channels",   nlohmann::json::array() },
-        { "events",     nlohmann::json::array() },
-        { "plugins",    nlohmann::json::array() },
-        { "servers",    nlohmann::json::array() }
-    });
+	auto json = nlohmann::json::object({
+		{ "command",    "rule-edit"             },
+		{ "channels",   nlohmann::json::array() },
+		{ "events",     nlohmann::json::array() },
+		{ "plugins",    nlohmann::json::array() },
+		{ "servers",    nlohmann::json::array() }
+	});
 
-    for (const auto& pair : result) {
-        // Action.
-        if (pair.first == "-a" || pair.first == "--action")
-            json["action"] = pair.second;
+	for (const auto& pair : result) {
+		// Action.
+		if (pair.first == "-a" || pair.first == "--action")
+			json["action"] = pair.second;
 
-        // Additions.
-        if (pair.first == "-c" || pair.first == "--add-channel")
-            json["add-channels"].push_back(pair.second);
-        if (pair.first == "-e" || pair.first == "--add-event")
-            json["add-events"].push_back(pair.second);
-        if (pair.first == "-p" || pair.first == "--add-plugin")
-            json["add-plugins"].push_back(pair.second);
-        if (pair.first == "-s" || pair.first == "--add-server")
-            json["add-servers"].push_back(pair.second);
+		// Additions.
+		if (pair.first == "-c" || pair.first == "--add-channel")
+			json["add-channels"].push_back(pair.second);
+		if (pair.first == "-e" || pair.first == "--add-event")
+			json["add-events"].push_back(pair.second);
+		if (pair.first == "-p" || pair.first == "--add-plugin")
+			json["add-plugins"].push_back(pair.second);
+		if (pair.first == "-s" || pair.first == "--add-server")
+			json["add-servers"].push_back(pair.second);
 
-        // Removals.
-        if (pair.first == "-C" || pair.first == "--remove-channel")
-            json["remove-channels"].push_back(pair.second);
-        if (pair.first == "-E" || pair.first == "--remove-event")
-            json["remove-events"].push_back(pair.second);
-        if (pair.first == "-P" || pair.first == "--remove-plugin")
-            json["remove-plugins"].push_back(pair.second);
-        if (pair.first == "-S" || pair.first == "--remove-server")
-            json["remove-servers"].push_back(pair.second);
-    }
+		// Removals.
+		if (pair.first == "-C" || pair.first == "--remove-channel")
+			json["remove-channels"].push_back(pair.second);
+		if (pair.first == "-E" || pair.first == "--remove-event")
+			json["remove-events"].push_back(pair.second);
+		if (pair.first == "-P" || pair.first == "--remove-plugin")
+			json["remove-plugins"].push_back(pair.second);
+		if (pair.first == "-S" || pair.first == "--remove-server")
+			json["remove-servers"].push_back(pair.second);
+	}
 
-    // Index.
-    const auto index = string_util::to_uint(copy[0]);
+	// Index.
+	const auto index = string_util::to_uint(copy[0]);
 
-    if (!index)
-        throw rule_error(rule_error::invalid_index);
+	if (!index)
+		throw rule_error(rule_error::invalid_index);
 
-    json["index"] = *index;
+	json["index"] = *index;
 
-    request(ctl, json);
+	request(ctl, json);
 }
 
 // }}}
@@ -623,59 +624,59 @@
 
 void rule_info_cli::print(const nlohmann::json& json, int index)
 {
-    assert(json.is_object());
+	assert(json.is_object());
 
-    const auto unjoin = [] (auto array) {
-        std::ostringstream oss;
+	const auto unjoin = [] (auto array) {
+		std::ostringstream oss;
 
-        for (auto it = array.begin(); it != array.end(); ++it) {
-            if (!it->is_string())
-                continue;
+		for (auto it = array.begin(); it != array.end(); ++it) {
+			if (!it->is_string())
+				continue;
 
-            oss << it->template get<std::string>() << " ";
-        }
+			oss << it->template get<std::string>() << " ";
+		}
 
-        return oss.str();
-    };
-    const auto unstr = [] (auto action) {
-        if (action.is_string() && action == "accept")
-            return "accept";
-        else
-            return "drop";
-    };
+		return oss.str();
+	};
+	const auto unstr = [] (auto action) {
+		if (action.is_string() && action == "accept")
+			return "accept";
+		else
+			return "drop";
+	};
 
-    std::cout << "rule:        " << index << std::endl;
-    std::cout << "servers:     " << unjoin(json["servers"]) << std::endl;
-    std::cout << "channels:    " << unjoin(json["channels"]) << std::endl;
-    std::cout << "plugins:     " << unjoin(json["plugins"]) << std::endl;
-    std::cout << "events:      " << unjoin(json["events"]) << std::endl;
-    std::cout << "action:      " << unstr(json["action"]) << std::endl;
-    std::cout << std::endl;
+	std::cout << "rule:        " << index << std::endl;
+	std::cout << "servers:     " << unjoin(json["servers"]) << std::endl;
+	std::cout << "channels:    " << unjoin(json["channels"]) << std::endl;
+	std::cout << "plugins:     " << unjoin(json["plugins"]) << std::endl;
+	std::cout << "events:      " << unjoin(json["events"]) << std::endl;
+	std::cout << "action:      " << unstr(json["action"]) << std::endl;
+	std::cout << std::endl;
 }
 
 auto rule_info_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-info";
+	return "rule-info";
 }
 
 void rule_info_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("rule-info requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("rule-info requires 1 argument");
 
-    const auto index = string_util::to_int(args[0]);
+	const auto index = string_util::to_int(args[0]);
 
-    if (!index)
-        throw rule_error(rule_error::invalid_index);
+	if (!index)
+		throw rule_error(rule_error::invalid_index);
 
-    const auto json = nlohmann::json::object({
-        { "command",    "rule-info" },
-        { "index",      *index      }
-    });
+	const auto json = nlohmann::json::object({
+		{ "command",    "rule-info"     },
+		{ "index",      *index          }
+	});
 
-    request(ctl, json, [index] (auto result) {
-        print(result, *index);
-    });
+	request(ctl, json, [index] (auto result) {
+		print(result, *index);
+	});
 }
 
 // }}}
@@ -684,19 +685,18 @@
 
 auto rule_list_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-list";
+	return "rule-list";
 }
 
 void rule_list_cli::exec(ctl::controller& ctl, const std::vector<std::string>&)
 {
-    request(ctl, {{ "command", "rule-list" }}, [] (auto result) {
-        auto pos = 0;
+	request(ctl, {{ "command", "rule-list" }}, [] (auto result) {
+		auto pos = 0;
 
-        for (const auto& obj : result["list"]) {
-            if (obj.is_object())
-                rule_info_cli::print(obj, pos++);
-        }
-    });
+		for (const auto& obj : result["list"])
+			if (obj.is_object())
+				rule_info_cli::print(obj, pos++);
+	});
 }
 
 // }}}
@@ -705,27 +705,27 @@
 
 auto rule_move_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-move";
+	return "rule-move";
 }
 
 void rule_move_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 2)
-        throw std::invalid_argument("rule-move requires 2 arguments");
+	if (args.size() < 2)
+		throw std::invalid_argument("rule-move requires 2 arguments");
 
-    const auto from = string_util::to_int<int>(args[0]);
-    const auto to = string_util::to_int<int>(args[1]);
+	const auto from = string_util::to_int<int>(args[0]);
+	const auto to = string_util::to_int<int>(args[1]);
 
-    if (!from)
-        throw rule_error(rule_error::invalid_index);
-    if (!to)
-        throw rule_error(rule_error::invalid_index);
+	if (!from)
+		throw rule_error(rule_error::invalid_index);
+	if (!to)
+		throw rule_error(rule_error::invalid_index);
 
-    request(ctl, {
-        { "command",    "rule-move" },
-        { "from",       *from       },
-        { "to",         *to         }
-    });
+	request(ctl, {
+		{ "command",    "rule-move"     },
+		{ "from",       *from           },
+		{ "to",         *to             }
+	});
 }
 
 // }}}
@@ -734,23 +734,23 @@
 
 auto rule_remove_cli::get_name() const noexcept -> std::string_view
 {
-    return "rule-remove";
+	return "rule-remove";
 }
 
 void rule_remove_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("rule-remove requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("rule-remove requires 1 argument");
 
-    const auto index = string_util::to_int(args[0]);
+	const auto index = string_util::to_int(args[0]);
 
-    if (!index)
-        throw rule_error(rule_error::invalid_index);
+	if (!index)
+		throw rule_error(rule_error::invalid_index);
 
-    request(ctl, {
-        { "command",    "rule-remove"   },
-        { "index",      *index          }
-    });
+	request(ctl, {
+		{ "command",    "rule-remove"   },
+		{ "index",      *index          }
+	});
 }
 
 // }}}
@@ -759,46 +759,46 @@
 
 auto server_connect_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-connect";
+	return "server-connect";
 }
 
 void server_connect_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    std::vector<std::string> copy(args);
+	std::vector<std::string> copy(args);
 
-    option::result result = parse(copy);
-    option::result::const_iterator it;
+	option::result result = parse(copy);
+	option::result::const_iterator it;
 
-    if (copy.size() < 2)
-        throw std::invalid_argument("server-connect requires at least 2 arguments");
+	if (copy.size() < 2)
+		throw std::invalid_argument("server-connect requires at least 2 arguments");
 
-    auto object = nlohmann::json::object({
-        { "command",    "server-connect"    },
-        { "name",       copy[0]             },
-        { "host",       copy[1]             }
-    });
+	auto object = nlohmann::json::object({
+		{ "command",    "server-connect"        },
+		{ "name",       copy[0]                 },
+		{ "host",       copy[1]                 }
+	});
 
-    if (copy.size() == 3) {
-        const auto port = string_util::to_int(copy[2]);
+	if (copy.size() == 3) {
+		const auto port = string_util::to_int(copy[2]);
 
-        if (!port)
-            throw std::invalid_argument("invalid port given");
+		if (!port)
+			throw std::invalid_argument("invalid port given");
 
-        object["port"] = *port;
-    }
+		object["port"] = *port;
+	}
 
-    if (result.count("-S") > 0 || result.count("--ssl-verify") > 0)
-        object["sslVerify"] = true;
-    if (result.count("-s") > 0 || result.count("--ssl") > 0)
-        object["ssl"] = true;
-    if ((it = result.find("-n")) != result.end() || (it = result.find("--nickname")) != result.end())
-        object["nickname"] = it->second;
-    if ((it = result.find("-r")) != result.end() || (it = result.find("--realname")) != result.end())
-        object["realname"] = it->second;
-    if ((it = result.find("-u")) != result.end() || (it = result.find("--username")) != result.end())
-        object["username"] = it->second;
+	if (result.count("-S") > 0 || result.count("--ssl-verify") > 0)
+		object["sslVerify"] = true;
+	if (result.count("-s") > 0 || result.count("--ssl") > 0)
+		object["ssl"] = true;
+	if ((it = result.find("-n")) != result.end() || (it = result.find("--nickname")) != result.end())
+		object["nickname"] = it->second;
+	if ((it = result.find("-r")) != result.end() || (it = result.find("--realname")) != result.end())
+		object["realname"] = it->second;
+	if ((it = result.find("-u")) != result.end() || (it = result.find("--username")) != result.end())
+		object["username"] = it->second;
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -807,19 +807,19 @@
 
 auto server_disconnect_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-disconnect";
+	return "server-disconnect";
 }
 
 void server_disconnect_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    auto object = nlohmann::json::object({
-        { "command", "server-disconnect" }
-    });
+	auto object = nlohmann::json::object({
+		{ "command", "server-disconnect" }
+	});
 
-    if (args.size() > 0)
-        object["server"] = args[0];
+	if (args.size() > 0)
+		object["server"] = args[0];
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -828,39 +828,39 @@
 
 auto server_info_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-info";
+	return "server-info";
 }
 
 void server_info_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 1)
-        throw std::invalid_argument("server-info requires 1 argument");
+	if (args.size() < 1)
+		throw std::invalid_argument("server-info requires 1 argument");
 
-    auto json = nlohmann::json::object({
-        { "command",    "server-info"   },
-        { "server",     args[0]         }
-    });
+	auto json = nlohmann::json::object({
+		{ "command",    "server-info"   },
+		{ "server",     args[0]         }
+	});
 
-    request(ctl, std::move(json), [] (auto result) {
-        std::cout << std::boolalpha;
-        std::cout << "Name           : " << json_util::pretty(result["name"]) << std::endl;
-        std::cout << "Host           : " << json_util::pretty(result["host"]) << std::endl;
-        std::cout << "Port           : " << json_util::pretty(result["port"]) << std::endl;
-        std::cout << "Ipv6           : " << json_util::pretty(result["ipv6"]) << std::endl;
-        std::cout << "SSL            : " << json_util::pretty(result["ssl"]) << std::endl;
-        std::cout << "SSL verified   : " << json_util::pretty(result["sslVerify"]) << std::endl;
-        std::cout << "Channels       : ";
+	request(ctl, std::move(json), [] (auto result) {
+		std::cout << std::boolalpha;
+		std::cout << "Name           : " << json_util::pretty(result["name"]) << std::endl;
+		std::cout << "Host           : " << json_util::pretty(result["host"]) << std::endl;
+		std::cout << "Port           : " << json_util::pretty(result["port"]) << std::endl;
+		std::cout << "Ipv6           : " << json_util::pretty(result["ipv6"]) << std::endl;
+		std::cout << "SSL            : " << json_util::pretty(result["ssl"]) << std::endl;
+		std::cout << "SSL verified   : " << json_util::pretty(result["sslVerify"]) << std::endl;
+		std::cout << "Channels       : ";
 
-        for (const auto& v : result["channels"])
-            if (v.is_string())
-                std::cout << v.template get<std::string>() << " ";
+		for (const auto& v : result["channels"])
+			if (v.is_string())
+				std::cout << v.template get<std::string>() << " ";
 
-        std::cout << std::endl;
+		std::cout << std::endl;
 
-        std::cout << "Nickname       : " << json_util::pretty(result["nickname"]) << std::endl;
-        std::cout << "User name      : " << json_util::pretty(result["username"]) << std::endl;
-        std::cout << "Real name      : " << json_util::pretty(result["realname"]) << std::endl;
-    });
+		std::cout << "Nickname       : " << json_util::pretty(result["nickname"]) << std::endl;
+		std::cout << "User name      : " << json_util::pretty(result["username"]) << std::endl;
+		std::cout << "Real name      : " << json_util::pretty(result["realname"]) << std::endl;
+	});
 }
 
 // }}}
@@ -869,20 +869,20 @@
 
 auto server_invite_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-invite";
+	return "server-invite";
 }
 
 void server_invite_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::invalid_argument("server-invite requires 3 arguments");
+	if (args.size() < 3)
+		throw std::invalid_argument("server-invite requires 3 arguments");
 
-    request(ctl, {
-        { "command",    "server-invite" },
-        { "server",     args[0]         },
-        { "target",     args[1]         },
-        { "channel",    args[2]         }
-    });
+	request(ctl, {
+		{ "command",    "server-invite" },
+		{ "server",     args[0]         },
+		{ "target",     args[1]         },
+		{ "channel",    args[2]         }
+	});
 }
 
 // }}}
@@ -891,24 +891,24 @@
 
 auto server_join_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-join";
+	return "server-join";
 }
 
 void server_join_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 2)
-        throw std::invalid_argument("server-join requires at least 2 arguments");
+	if (args.size() < 2)
+		throw std::invalid_argument("server-join requires at least 2 arguments");
 
-    auto object = nlohmann::json::object({
-        { "command",    "server-join"   },
-        { "server",     args[0]         },
-        { "channel",    args[1]         }
-    });
+	auto object = nlohmann::json::object({
+		{ "command",    "server-join"   },
+		{ "server",     args[0]         },
+		{ "channel",    args[1]         }
+	});
 
-    if (args.size() == 3)
-        object["password"] = args[2];
+	if (args.size() == 3)
+		object["password"] = args[2];
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -917,25 +917,25 @@
 
 auto server_kick_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-kick";
+	return "server-kick";
 }
 
 void server_kick_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::invalid_argument("server-kick requires at least 3 arguments ");
+	if (args.size() < 3)
+		throw std::invalid_argument("server-kick requires at least 3 arguments ");
 
-    auto object = nlohmann::json::object({
-        { "command",    "server-kick"   },
-        { "server",     args[0]         },
-        { "target",     args[1]         },
-        { "channel",    args[2]         }
-    });
+	auto object = nlohmann::json::object({
+		{ "command",    "server-kick"   },
+		{ "server",     args[0]         },
+		{ "target",     args[1]         },
+		{ "channel",    args[2]         }
+	});
 
-    if (args.size() == 4)
-        object["reason"] = args[3];
+	if (args.size() == 4)
+		object["reason"] = args[3];
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -944,16 +944,16 @@
 
 auto server_list_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-list";
+	return "server-list";
 }
 
 void server_list_cli::exec(ctl::controller& ctl, const std::vector<std::string>&)
 {
-    request(ctl, {{ "command", "server-list" }}, [] (auto result) {
-        for (const auto& n : result["list"])
-            if (n.is_string())
-                std::cout << n.template get<std::string>() << std::endl;
-    });
+	request(ctl, {{ "command", "server-list" }}, [] (auto result) {
+		for (const auto& n : result["list"])
+			if (n.is_string())
+				std::cout << n.template get<std::string>() << std::endl;
+	});
 }
 
 // }}}
@@ -962,20 +962,20 @@
 
 auto server_me_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-me";
+	return "server-me";
 }
 
 void server_me_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::runtime_error("server-me requires 3 arguments");
+	if (args.size() < 3)
+		throw std::runtime_error("server-me requires 3 arguments");
 
-    request(ctl, {
-        { "command",    "server-me" },
-        { "server",     args[0]     },
-        { "target",     args[1]     },
-        { "message",    args[2]     }
-    });
+	request(ctl, {
+		{ "command",    "server-me"     },
+		{ "server",     args[0]         },
+		{ "target",     args[1]         },
+		{ "message",    args[2]         }
+	});
 }
 
 // }}}
@@ -984,20 +984,20 @@
 
 auto server_message_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-message";
+	return "server-message";
 }
 
 void server_message_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::invalid_argument("server-message requires 3 arguments");
+	if (args.size() < 3)
+		throw std::invalid_argument("server-message requires 3 arguments");
 
-    request(ctl, {
-        { "command",    "server-message"    },
-        { "server",     args[0]             },
-        { "target",     args[1]             },
-        { "message",    args[2]             }
-    });
+	request(ctl, {
+		{ "command",    "server-message"        },
+		{ "server",     args[0]                 },
+		{ "target",     args[1]                 },
+		{ "message",    args[2]                 }
+	});
 }
 
 // }}}
@@ -1006,29 +1006,29 @@
 
 auto server_mode_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-mode";
+	return "server-mode";
 }
 
 void server_mode_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 2)
-        throw std::invalid_argument("server-mode requires at least 3 arguments");
+	if (args.size() < 2)
+		throw std::invalid_argument("server-mode requires at least 3 arguments");
 
-    auto json = nlohmann::json({
-        { "command",    "server-mode"   },
-        { "server",     args[0]         },
-        { "channel",    args[1]         },
-        { "mode",       args[2]         }
-    });
+	auto json = nlohmann::json({
+		{ "command",    "server-mode"   },
+		{ "server",     args[0]         },
+		{ "channel",    args[1]         },
+		{ "mode",       args[2]         }
+	});
 
-    if (args.size() >= 4)
-        json["limit"] = args[3];
-    if (args.size() >= 5)
-        json["user"] = args[4];
-    if (args.size() >= 6)
-        json["mask"] = args[5];
+	if (args.size() >= 4)
+		json["limit"] = args[3];
+	if (args.size() >= 5)
+		json["user"] = args[4];
+	if (args.size() >= 6)
+		json["mask"] = args[5];
 
-    request(ctl, std::move(json));
+	request(ctl, std::move(json));
 }
 
 // }}}
@@ -1037,19 +1037,19 @@
 
 auto server_nick_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-nick";
+	return "server-nick";
 }
 
 void server_nick_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 2)
-        throw std::invalid_argument("server-nick requires 2 arguments");
+	if (args.size() < 2)
+		throw std::invalid_argument("server-nick requires 2 arguments");
 
-    request(ctl, {
-        { "command",    "server-nick"   },
-        { "server",     args[0]         },
-        { "nickname",   args[1]         }
-    });
+	request(ctl, {
+		{ "command",    "server-nick"   },
+		{ "server",     args[0]         },
+		{ "nickname",   args[1]         }
+	});
 }
 
 // }}}
@@ -1058,20 +1058,20 @@
 
 auto server_notice_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-notice";
+	return "server-notice";
 }
 
 void server_notice_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::invalid_argument("server-notice requires 3 arguments");
+	if (args.size() < 3)
+		throw std::invalid_argument("server-notice requires 3 arguments");
 
-    request(ctl, {
-        { "command",    "server-notice" },
-        { "server",     args[0]         },
-        { "target",     args[1]         },
-        { "message",    args[2]         }
-    });
+	request(ctl, {
+		{ "command",    "server-notice" },
+		{ "server",     args[0]         },
+		{ "target",     args[1]         },
+		{ "message",    args[2]         }
+	});
 }
 
 // }}}
@@ -1080,24 +1080,24 @@
 
 auto server_part_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-part";
+	return "server-part";
 }
 
 void server_part_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 2)
-        throw std::invalid_argument("server-part requires at least 2 arguments");
+	if (args.size() < 2)
+		throw std::invalid_argument("server-part requires at least 2 arguments");
 
-    auto object = nlohmann::json::object({
-        { "command",    "server-part"   },
-        { "server",     args[0]         },
-        { "channel",    args[1]         }
-    });
+	auto object = nlohmann::json::object({
+		{ "command",    "server-part"   },
+		{ "server",     args[0]         },
+		{ "channel",    args[1]         }
+	});
 
-    if (args.size() >= 3)
-        object["reason"] = args[2];
+	if (args.size() >= 3)
+		object["reason"] = args[2];
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -1106,19 +1106,19 @@
 
 auto server_reconnect_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-reconnect";
+	return "server-reconnect";
 }
 
 void server_reconnect_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    auto object = nlohmann::json::object({
-        { "command", "server-reconnect" }
-    });
+	auto object = nlohmann::json::object({
+		{ "command", "server-reconnect" }
+	});
 
-    if (args.size() >= 1)
-        object["server"] = args[0];
+	if (args.size() >= 1)
+		object["server"] = args[0];
 
-    request(ctl, object);
+	request(ctl, object);
 }
 
 // }}}
@@ -1127,20 +1127,20 @@
 
 auto server_topic_cli::get_name() const noexcept -> std::string_view
 {
-    return "server-topic";
+	return "server-topic";
 }
 
 void server_topic_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    if (args.size() < 3)
-        throw std::invalid_argument("server-topic requires 3 arguments");
+	if (args.size() < 3)
+		throw std::invalid_argument("server-topic requires 3 arguments");
 
-    request(ctl, {
-        { "command",    "server-topic"  },
-        { "server",     args[0]         },
-        { "channel",    args[1]         },
-        { "topic",      args[2]         }
-    });
+	request(ctl, {
+		{ "command",    "server-topic"  },
+		{ "server",     args[0]         },
+		{ "channel",    args[1]         },
+		{ "topic",      args[2]         }
+	});
 }
 
 // }}}
@@ -1149,17 +1149,17 @@
 
 auto watch_cli::get_name() const noexcept -> std::string_view
 {
-    return "watch";
+	return "watch";
 }
 
 void watch_cli::exec(ctl::controller& ctl, const std::vector<std::string>& args)
 {
-    auto fmt = format(args);
+	const auto fmt = format(args);
 
-    if (fmt != "native" && fmt != "json")
-        throw std::invalid_argument("invalid format given: " + fmt);
+	if (fmt != "native" && fmt != "json")
+		throw std::invalid_argument("invalid format given: " + fmt);
 
-    get_event(ctl, fmt);
+	get_event(ctl, fmt);
 }
 
 // }}}