yeschief.h

/*
 * MIT License
 *
 * Copyright (c) 2025-Present Kevin Traini
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#pragma once
#ifndef YESCHIEF_H
#define YESCHIEF_H
 
#include <any>
#include <cassert>
#include <expected>
#include <iostream>
#include <map>
#include <memory>
#include <optional>
#include <regex>
#include <string>
#include <vector>
 
#define assert_message(expr, message) assert((message, expr))
 
namespace yeschief {
class CLI;
class OptionGroup;
class Command;
class CLIResults;

typedef struct OptionConfiguration {
    bool required                          = false;
    std::string value_help                 = "VALUE";
    std::optional<std::any> default_value  = std::nullopt;
    std::optional<std::any> implicit_value = std::nullopt;
} OptionConfiguration;

enum class FaultType {
    InvalidArgs,
    UnrecognizedOption,
    MissingRequiredOption,
    InvalidOptionType,
    MissingOptionValue,
    UnknownCommand,
};

typedef struct Fault {
    std::string message;
    FaultType type;
} Fault;

struct Option {
    std::string name;
    std::string short_name;
    std::string description;
    const std::type_info &type;
    OptionConfiguration configuration;
};

class OptionGroup final {
    friend class CLI;
 
  public:
    explicit OptionGroup(CLI *parent, std::string name);

    template<typename T = bool>
    auto
    addOption(const std::string &name, const std::string &description, const OptionConfiguration &configuration = {})
        -> OptionGroup &;
 
  private:
    CLI *_parent;
    std::string _name;
    std::vector<std::shared_ptr<const Option>> _options;
 
    auto addOption(const std::shared_ptr<Option> &option) -> void;
};

class CLI final {
    friend class OptionGroup;
    friend class HelpCommand;
 
    enum class Mode { OPTIONS, COMMANDS };
 
  public:
    CLI(std::string name, std::string description);

    template<typename T = bool>
    auto
    addOption(const std::string &name, const std::string &description, const OptionConfiguration &configuration = {})
        -> CLI &;

    [[nodiscard]] auto addGroup(const std::string &name) -> OptionGroup &;

    auto addCommand(Command *command) -> CLI &;

    template<typename... Tail> auto parsePositional(const std::string &option_name, Tail &&...options) -> void;

    auto run(int argc, char **argv) const -> std::expected<CLIResults, Fault>;

    auto help(std::ostream &out = std::cout) const -> void;
 
  private:
    std::string _name;
    std::string _description;
    std::optional<Mode> _mode;
    std::map<std::string, OptionGroup> _groups;
    std::map<std::string, std::shared_ptr<const Option>> _options;
    std::vector<std::string> _positional_options;
    std::map<std::string, Command *> _commands;
    std::map<std::string, CLI> _commands_cli;
 
    [[nodiscard]] auto buildUsageHelp() const -> std::string;
 
    [[nodiscard]] auto buildPositionalHelp() const -> std::string;
 
    [[nodiscard]] static auto buildOptionUsageHelp(const std::shared_ptr<const Option> &option) -> std::string;
 
    static auto checkOptionType(const std::type_info &type) -> void;
 
    [[nodiscard]] static auto
    getValueForOption(const std::shared_ptr<const Option> &option, const std::vector<std::string> &values)
        -> std::expected<std::any, Fault>;
 
    template<typename T = bool>
    auto addOption(
        const std::string &name,
        const std::string &description,
        const std::string &group_name,
        const OptionConfiguration &configuration
    ) -> CLI &;
 
    auto parsePositional() -> void {
        // Nothing to do here
    }
};

class Command {
  public:
    [[nodiscard]] virtual auto getName() const -> std::string = 0;
    [[nodiscard]] virtual auto getDescription() const -> std::string {
        return "";
    }

    virtual auto setup(CLI &cli) -> void {}

    virtual auto run(const CLIResults &results) -> int = 0;
 
    virtual ~Command() = default;
};

class CLIResults final {
  public:
    explicit CLIResults(const std::map<std::string, std::any> &values);

    [[nodiscard]] auto get(const std::string &option) const -> std::optional<std::any>;
 
  private:
    std::map<std::string, std::any> _values;
};

class HelpCommand final : public Command {
  public:
    explicit HelpCommand(CLI *cli): _cli(cli) {}
 
    [[nodiscard]] auto getName() const -> std::string override {
        return "help";
    }
 
    [[nodiscard]] auto getDescription() const -> std::string override {
        return "Display this help message\n"
               "When COMMAND is given, display help for this command";
    }
 
    auto setup(CLI &cli) -> void override;
 
    auto run(const CLIResults &results) -> int override;
 
  private:
    CLI *_cli;
};
} // namespace yeschief
 
template<typename T>
auto yeschief::OptionGroup::addOption(
    const std::string &name, const std::string &description, const OptionConfiguration &configuration
) -> OptionGroup & {
    _parent->addOption<T>(name, description, _name, configuration);
    return *this;
}
 
template<typename T>
auto yeschief::CLI::addOption(
    const std::string &name, const std::string &description, const OptionConfiguration &configuration
) -> CLI & {
    return addOption<T>(name, description, "", configuration);
}
 
template<typename T>
auto yeschief::CLI::addOption(
    const std::string &name,
    const std::string &description,
    const std::string &group_name,
    const OptionConfiguration &configuration
) -> CLI & {
    assert_message(
        ! _mode.has_value() || _mode.value() != Mode::COMMANDS, "Cannot add an option group to a cli using commands"
    );
    _mode = Mode::OPTIONS;
 
    assert_message(! _options.contains(name), "CLI has already this option");
    assert_message(_groups.contains(group_name), "Option group does not exist");
 
    std::string long_name = name;
    std::string short_name;
    const std::regex name_regex("(.*),(.*)");
    if (std::smatch match; std::regex_match(name, match, name_regex)) {
        if (match.size() == 3) {
            long_name  = match[1].str();
            short_name = match[2].str();
            assert_message(
                short_name.length() == 1 && isalpha(short_name[0]), "Short name of an option can be only one letter"
            );
        }
    }
 
    const auto &type_info = typeid(T);
    checkOptionType(type_info);
    const auto option = std::make_shared<Option>(long_name, short_name, description, type_info, configuration);
    _options.emplace(long_name, option);
    _groups.at(group_name).addOption(option);
 
    return *this;
}
 
template<typename... Tail>
auto yeschief::CLI::parsePositional(const std::string &option_name, Tail &&...options) -> void {
    assert_message(_options.contains(option_name), "Option doesn't exists");
    const auto option = _options.at(option_name);
    if (! _positional_options.empty()) {
        const auto last_option_name  = _positional_options[_positional_options.size() - 1];
        const auto last_option       = _options.at(last_option_name);
        const auto &last_option_type = last_option->type;
        assert_message(
            last_option_type != typeid(std::vector<int>) && last_option_type != typeid(std::vector<float>)
                && last_option_type != typeid(std::vector<double>),
            "Cannot add a new positional argument after one with a list type"
        );
        assert_message(
            ! option->configuration.required || last_option->configuration.required,
            "Option is required but is placed after a non required one"
        );
    }
 
    _positional_options.push_back(option_name);
    parsePositional(std::forward<Tail>(options)...);
}
 
#endif // YESCHIEF_H