CommandRouter.cpp

Go to the documentation of this file.

#include "Commands/CommandRouter.hpp"
 
#include "Commands/CommandSyntax.hpp"
 
#include <VoltMod/Core/Log.hpp>
#include <VoltMod/Core/Text/EnumNames.hpp>
#include <VoltMod/Core/Text/Strings.hpp>
#include <algorithm>
#include <cctype>
#include <utility>
 
namespace VoltMod
{
 
/** The line a failed handler replies with: its own localized line, else its key, else the log text. */
static std::string FailureLine(const Error& error, const Translations& translations, int slot)
{
    if (!error.Text.empty())
    {
        return error.Text;
    }
    if (!error.Key.empty())
    {
        return translations.Get(error.Key, slot);
    }
    return error.Detail;
}
 
/** Translation key for an argument kind's usage placeholder. */
static std::string UsagePlaceholderKey(ArgKind kind)
{
    std::string key = "cmd.usage.";
    const std::string_view name = Name(kind);
    if (!name.empty())
    {
        key += static_cast<char>(std::tolower(static_cast<unsigned char>(name.front())));
        key += name.substr(1);
    }
    return key;
}
 
const CommandDefinition* CommandRouter::Add(CommandDefinition def)
{
    const std::string name = Strings::ToLower(def.Name);
 
    if (name.empty())
    {
        Log::Error("A command was registered with no name - ignoring it.");
        return nullptr;
    }
    if (_commands.contains(name) || _aliases.contains(name))
    {
        Log::Error("Command '{}' is already registered - ignoring the second registration.", def.Name);
        return nullptr;
    }
    if (_host && !_host->RegisterCommand(name))
    {
        Log::Error("Command '{}' is held by another plugin - ignoring this registration.", def.Name);
        return nullptr;
    }
 
    // Index aliases once so lookup is deterministic.
    for (const std::string& alias : def.Aliases)
    {
        std::string key = Strings::ToLower(alias);
        if (key.empty() || key == name)
        {
            continue;
        }
        if (_commands.contains(key))
        {
            Log::Error("Command '{}' asks for alias '{}', which is already a command name - skipping the alias.",
                       def.Name, alias);
            continue;
        }
        if (auto it = _aliases.find(key); it != _aliases.end())
        {
            Log::Error("Command '{}' asks for alias '{}', already taken by '{}' - skipping the alias.", def.Name, alias,
                       it->second);
            continue;
        }
        if (_host && !_host->RegisterCommand(key))
        {
            Log::Error("Command '{}' asks for alias '{}', which another plugin owns - skipping the alias.", def.Name,
                       alias);
            continue;
        }
        _aliases.emplace(std::move(key), name);
    }
 
    CommandDefinition& stored = _commands[name];
    stored = std::move(def);
    return &stored;
}
 
void CommandRouter::Clear()
{
    _commands.clear();
    _aliases.clear();
}
 
const CommandDefinition* CommandRouter::Find(std::string_view name) const
{
    const std::string key = Strings::ToLower(std::string(name));
 
    if (auto it = _commands.find(key); it != _commands.end())
    {
        return &it->second;
    }
 
    if (auto alias = _aliases.find(key); alias != _aliases.end())
    {
        if (auto it = _commands.find(alias->second); it != _commands.end())
        {
            return &it->second;
        }
    }
 
    return nullptr;
}
 
bool CommandRouter::IsForeign(std::string_view name) const
{
    return _host && !Find(name) && _host->IsCommandRegistered(Strings::ToLower(std::string(name)));
}
 
size_t CommandRouter::RequiredArgs(const CommandDefinition& def)
{
    return static_cast<size_t>(
        std::count_if(def.Args.begin(), def.Args.end(), [](const ArgDesc& arg) { return !arg.Optional; }));
}
 
bool CommandRouter::HasRest(const CommandDefinition& def)
{
    return std::any_of(def.Args.begin(), def.Args.end(), [](const ArgDesc& arg) { return arg.Kind == ArgKind::Rest; });
}
 
Tokens CommandRouter::UsageTokens(const CommandDefinition& def, int slot, Origin origin) const
{
    // Only chat usage includes a prefix.
    std::string prefix = origin == Origin::Chat ? std::string(CommandSyntax::ChatPrefix) : std::string{};
 
    std::string args;
    for (const ArgDesc& arg : def.Args)
    {
        if (!args.empty())
        {
            args += ' ';
        }
        const std::string placeholder = _translations.Get(UsagePlaceholderKey(arg.Kind), slot);
        args += arg.Optional ? '[' : '<';
        args += placeholder;
        args += arg.Optional ? ']' : '>';
    }
 
    std::string line = prefix + def.Name;
    if (!args.empty())
    {
        line += ' ' + args;
    }
 
    return {{"prefix", prefix}, {"command", def.Name}, {"args", args}, {"usage", line}};
}
 
std::string CommandRouter::Usage(const CommandDefinition& def, int slot, Origin origin) const
{
    if (!def.UsageKey.empty())
    {
        return _translations.Get(def.UsageKey, slot);
    }
    return _translations.Get("cmd.usage", slot, UsageTokens(def, slot, origin));
}
 
void CommandRouter::Dispatch(const CommandDefinition& def, Player* caller, std::span<const std::string> tokens,
                             Origin origin, ArgBinder& binder, const std::function<void(const std::string&)>& say) const
{
    // Slot -1 selects the server language for console calls.
    const int slot = caller ? caller->Slot() : -1;
    const auto reply = [&say](const std::string& line) {
        if (!line.empty())
        {
            say(line);
        }
    };
 
    // Apply the permission gate to player callers; the console is the server.
    if (caller && !def.PermissionName.empty())
    {
        auto authorized = _policy.Authorize(caller->Ref(), std::nullopt, def.PermissionName);
        if (!authorized)
        {
            reply(_translations.Get(authorized.error().Key, slot));
            return;
        }
    }
 
    // Reject extra tokens unless the final argument consumes the remainder.
    if (!HasRest(def) && tokens.size() > def.Args.size())
    {
        reply(_translations.Get("cmd.tooManyArgs", slot, UsageTokens(def, slot, origin)));
        return;
    }
 
    if (tokens.size() < RequiredArgs(def))
    {
        reply(Usage(def, slot, origin));
        return;
    }
 
    auto bound = BindArgs(def, tokens, caller, binder);
    if (!bound)
    {
        reply(_translations.Get(bound.error().Key, slot, bound.error().Vars));
        return;
    }
 
    if (!def.Invoke)
    {
        return;
    }
 
    const Caller who{.Player = caller, .Slot = slot, .Translations = _translations, .Send = say};
    auto result = def.Invoke(who, *bound);
    reply(result ? result->Text : FailureLine(result.error(), _translations, slot));
}
 
}  // namespace VoltMod