cmdopt.cpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#include "shambase/exception.hpp"
#include "shambase/print.hpp"
#include "shambase/string.hpp"
#include "shambase/term_colors.hpp"
#include "shamcmdopt/cmdopt.hpp"
#include "shamcmdopt/details/generic_opts.hpp"
#include "shamcmdopt/env.hpp"
#include <string_view>
#include <algorithm>
#include <iostream>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
class ShamCmdOptException : public std::exception {
    public:
    explicit ShamCmdOptException(const char *message) : msg_(message) {}
 
    explicit ShamCmdOptException(const std::string &message) : msg_(message) {}
 
    virtual ~ShamCmdOptException() noexcept {}
 
    virtual const char *what() const noexcept { return msg_.c_str(); }
 
    protected:
    std::string msg_;
};
 
namespace shamcmdopt {
 
    auto err_str = []() {
        return "[" + shambase::term_colors::col8b_red() + "Error" + shambase::term_colors::reset()
               + "]";
    };
 
    std::string_view executable_name;   
    std::vector<std::string_view> args; 
    bool init_done;                     
 
    struct Opts {
        std::string name;                
        std::optional<std::string> args; 
        std::string description;         
    };
 
    std::vector<Opts> registered_opts;
 
    bool is_name_registered(const std::string_view &name) {
        for (const auto &opt : registered_opts) {
            if (opt.name == name) {
                return true;
            }
        }
        return false;
    }
 
    void check_args_registered() {
        bool error = false;
 
        std::string err_buf;
 
        for (auto arg : args) {
            if (arg.rfind("-", 0) == 0) {
                if (!is_name_registered(arg)) {
                    shambase::println(
                        err_str() + " opts argument : " + std::string(arg) + " is not registered");
                    err_buf += "\"";
                    err_buf += arg;
                    err_buf += "\"";
                    err_buf += " ";
                    error = true;
                }
            }
        }
 
        if (error) {
            print_help();
            throw ShamCmdOptException(err_buf + "names are not registered in ::opts");
        }
    }
 
    void check_init() {
        if (!init_done)
            throw ShamCmdOptException("Cmdopt uninitialized");
    }
 
    bool has_option(const std::string_view &option_name) {
        check_init(); // We must init the cmdopt before checking if an option is there
 
        if (!is_name_registered(option_name)) {
            shambase::println(
                err_str() + " opts argument :" + std::string(option_name) + " is not registered");
            throw ShamCmdOptException(
                std::string(option_name) + " option is not registered in ::opts");
        }
 
        for (auto it = args.begin(), end = args.end(); it != end; ++it) {
            if (*it == option_name)
                return true;
        }
 
        return false;
    }
 
    std::string_view get_option(const std::string_view &option_name) {
        check_init();
 
        if (!is_name_registered(option_name)) {
            shambase::println(
                err_str() + " opts argument :" + std::string(option_name) + "is not registered");
            throw ShamCmdOptException(
                std::string(option_name) + " option is not registered in ::opts");
        }
 
        for (auto it = args.begin(), end = args.end(); it != end; ++it) {
            if (*it == option_name)
                if (it + 1 != end)
                    return *(it + 1);
        }
 
        return "";
    }
 
    void register_opt(std::string name, std::optional<std::string> args, std::string description) {
 
        for (auto &[n, arg, desc] : registered_opts) {
            if (name == n) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("The option {} is already registered", name));
            }
        }
 
        registered_opts.push_back({name, std::move(args), std::move(description)});
    }
 
    int argc;
 
    char **argv;
 
    void init(int _argc, char *_argv[]) {
        argc = _argc;
        argv = _argv;
 
        register_cmdopt_generic_opts();
 
        executable_name = std::string_view(argv[0]);
        args            = std::vector<std::string_view>(argv + 1, argv + argc);
        init_done       = true;
        check_args_registered();
 
        process_cmdopt_generic_opts();
    }
 
    int get_argc() {
        if (init_done) {
            return argc;
        }
        return 0;
    }
    char **get_argv() {
        if (init_done) {
            return argv;
        }
        return 0;
    }
 
    void print_help() {
        shambase::println(shambase::format("executable : {}", executable_name));
 
        fmt::println("\nUsage :");
 
        std::sort(
            registered_opts.begin(), registered_opts.end(), [](const auto &lhs, const auto &rhs) {
                return lhs.name < rhs.name;
            });
 
        for (auto &[n, arg, desc] : registered_opts) {
 
            std::string arg_print = arg.value_or("");
 
            shambase::println(
                shambase::format_printf(
                    "%-15s %-15s : %s", n.c_str(), arg_print.c_str(), desc.c_str()));
        }
        print_help_env_var();
    }
 
    void print_completion_zsh() {
 
        std::string exe(executable_name);
 
        // keep only the executable name
        exe = exe.substr(exe.find_last_of('/') + 1);
 
        // Header required by zsh
        shambase::println("#compdef " + exe);
        shambase::println("");
 
        // Function name must be _<cmd>
        shambase::println("_" + exe + "() {");
        shambase::println("  _arguments \\");
 
        std::sort(
            registered_opts.begin(), registered_opts.end(), [](const auto &lhs, const auto &rhs) {
                return lhs.name < rhs.name;
            });
 
        for (size_t i = 0; i < registered_opts.size(); ++i) {
            const auto &[name, arg, desc] = registered_opts[i];
 
            std::string entry;
 
            if (arg.has_value()) {
                // Option takes a value
                // Example: --output=[Output file]:file:_files
                entry = "'" + name + "[" + desc + "]:" + arg.value() + "'";
            } else {
                // Flag without value
                // Example: --help[Show help]
                entry = "'" + name + "[" + desc + "]'";
            }
 
            // Add trailing backslash except last line
            if (i != registered_opts.size() - 1)
                entry += " \\";
 
            shambase::println("    " + entry);
        }
 
        shambase::println("");
        shambase::println("}");
        shambase::println("");
 
        shambase::println("compdef _" + exe + " " + exe + " */" + exe);
    }
 
    bool is_help_mode() { return has_option("--help"); }
 
} // namespace shamcmdopt