orchestrator_helper.hpp

Go to the documentation of this file.

#pragma once
 
#include <arkanjo/base/path.hpp>
 
#include <arkanjo/base/similarity_table.hpp>
 
#include <arkanjo/cli/parser_options.hpp>
#include <arkanjo/orchestrator.hpp>
#include <arkanjo/commands/command.hpp>
#include <arkanjo/commands/commands_registry.hpp>
#include <arkanjo/base/preprocess_state.hpp>
 
namespace OrchestratorHelper {
static constexpr const char* DEFAULT_COMMAND = "help";
 
constexpr CliOption global_long_opts[] = {
    {"name", 'n', RequiredArgument, "Assign a name to the cache container; defaults to 'default' if not provided."},
    {"color", 0, NoArgument, "Enable colored output."},
    {"no-color", 0, NoArgument, "Disable colored output."},
    {"json", 0, NoArgument, "Json output."},
    {"similarity", 'S', RequiredArgument, "Changes the similarity threshold to `SIMILARITY` for the current command only."},
    {"help", 'h', NoArgument, "Show this help message."},
    OPTION_END
};
 
inline Step setup_command_step(
    std::unique_ptr<ICommand>& command,
    const std::vector<std::pair<std::vector<std::string>, CommandsRegistry::CommandFactory>>& commands
) {
    return [&command, &commands](Context& ctx) mutable {
        command = CommandsRegistry::get_command(ctx.command_name, commands);
        if (command.get() != nullptr) {
            return true;
        }
 
        std::string external_cmd = Config::config().program_name + "-" + ctx.command_name;
        std::vector<char*> new_argv;
        new_argv.push_back(const_cast<char*>(external_cmd.c_str()));
        for (int i = 2; i < ctx.argc; ++i) {
            new_argv.push_back(ctx.argv[i]);
        }
        new_argv.push_back(nullptr);
        UtilsOSDependable::run_process(external_cmd.c_str(), new_argv.data());
 
        throw CommandNotFoundError(ctx.command_name);
 
        return true;
    };
}
 
inline bool formatter_step(Context& ctx) {
    enum Format format_output = Format::TEXT;
    if (ctx.options.has("json"))
        format_output = Format::JSON;
    FormatterManager::set_format(format_output);
    FormatterManager::set_formatter(std::make_shared<ConsoleFormatter>(true));
    if (ctx.options.has("no-color"))
        FormatterManager::set_formatter(std::make_shared<ConsoleFormatter>(false));
    return true;
}
 
inline Step similarity_step(Similarity_Table& table) {
    return [&table](Context& ctx) {
        auto result = table.load();
        
        if (result == Similarity_Table::Cache_Compatibility::Fail) {
            auto params = Preprocess_State::read_current_run_params();
 
            FormatterManager::warn(
            "Cache generated with Arkanjo v" +
            (!params.version.empty() ? params.version : "?.?.?") +
            " may be incompatible with the current version v" +
            std::string(Config::config().project_version) +
            ". Results may be inaccurate.");
        }
 
        if (auto similarity = ctx.options.get_as<double>("similarity"))
            table.update_similarity(*similarity);
 
        return true;
    };
}
 
inline Step command_run_step(std::shared_ptr<ICommand> command, const OptionsCollector& collector) {
    return [cmd = std::move(command), &collector](Context& ctx) mutable {
        return cmd->validate(ctx.options) && cmd->do_run(ctx.command_name, ctx.options, &collector);
    };
}
} // namespace OrchestratorHelper