CommandLineParser.hpp

// Copyright Take Vos 2019-2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "datum.hpp"
#include <string>
#include <vector>
#include <map>
#include <functional>
#include <string_view>
#include <iostream>
 
namespace hi::inline v1 {
 
class CommandLineParser {
    struct option_t {
        std::string name;
 
        datum_type_t type;
 
        std::string help;
 
        std::function<int(std::string_view)> enum_conversion;
 
        option_t(std::string name, datum_type_t type, std::string help, std::function<int(std::string_view)> enum_conversion) :
            name(std::move(name)), type(type), help(std::move(help)), enum_conversion(std::move(enum_conversion))
        {
        }
    };
 
    // The synopsis of the application to be printed on --help and error.
    std::string synopsis;
 
    // A list of options.
    std::vector<option_t> options;
 
    std::vector<std::string> error_messages;
 
public:
    CommandLineParser(std::string synopsis) : synopsis(std::move(synopsis)) {}
 
    void
    add(std::string name, datum_type_t type, std::string help, std::function<int(std::string_view)> enum_conversion = {}) noexcept
    {
        options.emplace_back(std::move(name), type, std::move(help), std::move(enum_conversion));
    }
 
    bool has_error() const noexcept
    {
        return error_messages.size() > 0;
    }
 
    void print_help()
    {
        for (hilet &error_message : error_messages) {
            std::cerr << error_message << "\n";
        }
        if (has_error()) {
            std::cerr << "\n";
        }
 
        std::cerr << synopsis << "\n";
 
        for (hilet &option : options) {
            hilet example = std::format("--{}=<{}>", option.name, option.type);
            std::cerr << std::format("  {:20s}    {}\n", example, option.help);
        }
        std::cerr.flush();
    }
 
    datum parse(int argc, char const *const argv[]) noexcept
    {
        auto r = datum{datum::map{}};
 
        for (int arg_index = 0; arg_index != argc; ++arg_index) {
            auto argument = std::string(argv[arg_index]);
 
            if (arg_index == 0) {
                r["executable-path"] = argument;
 
            } else if (argument.starts_with("--"s)) {
                hilet i = argument.find('=');
                if (i == argument.npos) {
                    hilet option_name = argument.substr(2);
 
                    hilet &option = std::find_if(options.begin(), options.end(), [&](auto x) {
                        return x.name == option_name;
                    });
 
                    if (option == options.end()) {
                        error_messages.push_back(std::format("Unknown option '{}'", option_name));
 
                    } else if (option->type != datum_type_t::Boolean) {
                        error_messages.push_back(std::format("Option '{}' requires an argument", option_name));
 
                    } else {
                        r[option_name] = true;
                    }
 
                } else {
                    hilet option_name = argument.substr(2, i - 2);
                    hilet option_value_string = argument.substr(i + 1);
 
                    hilet &option = std::find_if(options.begin(), options.end(), [&](auto x) {
                        return x.name == option_name;
                    });
 
                    if (option == options.end()) {
                        error_messages.push_back(std::format("Unknown option '{}'", option_name));
 
                    } else {
                        switch (option->type) {
                        case datum_type_t::Boolean:
                            if (option_value_string == "true") {
                                r[option_name] = true;
                            } else if (option_value_string == "false") {
                                r[option_name] = false;
                            } else {
                                error_messages.push_back(std::format(
                                    "Expected a boolean value ('true' or 'false') for option '{}' got '{}'",
                                    option_name,
                                    option_value_string));
                            }
                            break;
 
                        case datum_type_t::Integer:
                            if (option->enum_conversion) {
                                hilet option_value_int = option->enum_conversion(option_value_string);
                                if (option_value_int >= 0) {
                                    r[option_name] = option_value_int;
                                } else {
                                    error_messages.push_back(
                                        std::format("Unknown value '{}' for option '{}'", option_value_string, option_name));
                                }
 
                            } else {
                                try {
                                    hilet option_value_int = std::stoll(option_value_string);
                                    r[option_name] = option_value_int;
                                } catch (...) {
                                    error_messages.push_back(std::format(
                                        "Expected a integer value for option '{}' got '{}'", option_name, option_value_string));
                                }
                            }
                            break;
 
                        case datum_type_t::String: r[option_name] = option_value_string; break;
 
                        case datum_type_t::Vector: r[option_name].push_back(datum{option_value_string}); break;
 
                        case datum_type_t::URL:
                            r[option_name] = URL::urlFromCurrentWorkingDirectory().urlByAppendingPath(option_value_string);
                            break;
 
                        default: hi_no_default();
                        }
                    }
                }
 
            } else {
                r["arguments"].push_back(argument);
            }
        }
        return r;
    }
};
 
} // namespace hi::inline v1