format_tdl.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2023, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2023, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/sharg-parser/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <concepts>
#include <numeric>
 
#include <sharg/detail/format_base.hpp>
#include <sharg/validators.hpp>
 
#include <tdl/ParamDocumentToCTD.h>
#include <tdl/ParamDocumentToCWL.h>
 
namespace sharg::detail
{
 
inline auto to_tdl(bool v)
{
    return tdl::BoolValue(v);
}
 
auto to_tdl(std::integral auto v)
{
    return tdl::IntValue(v);
}
 
auto to_tdl(std::floating_point auto v)
{
    return tdl::DoubleValue(v);
}
 
inline auto to_tdl(std::string const & v)
{
    return tdl::StringValue(v);
}
 
auto to_tdl(auto SHARG_DOXYGEN_ONLY(v))
{
    return tdl::BoolValue(false);
}
 
class format_tdl : format_base
{
public:
    enum class FileFormat
    {
        CTD, 
        CWL, 
    };
 
    std::vector<std::function<void(std::string_view)>> parser_set_up_calls;
    std::vector<std::function<void(std::string_view)>> positional_option_calls; // singled out to be printed on top
    unsigned positional_option_count{0};
    std::vector<std::string> command_names{};
 
    tdl::ToolInfo info;
 
    FileFormat fileFormat;
 
    parser_meta_data meta;
 
public:
    format_tdl(FileFormat fileFormat) : fileFormat{fileFormat}
    {}
 
    format_tdl(format_tdl const &) = default;             
    format_tdl & operator=(format_tdl const &) = default; 
    format_tdl(format_tdl &&) = default;                  
    format_tdl & operator=(format_tdl &&) = default;      
    ~format_tdl() = default;                              
 
    template <typename option_type, typename config_type>
    void add_option(option_type & value, config_type const & config)
    {
        auto description = config.description;
        description += (config.required ? std::string{" "} : detail::to_string(" Default: ", value, ". "));
        description += config.validator.get_help_page_message();
 
        auto tags = std::set<std::string>{};
        if (config.required)
        {
            tags.insert("required");
        }
        if (config.advanced)
        {
            tags.insert("advanced");
        }
        if constexpr (std::same_as<std::filesystem::path, option_type>)
        {
            auto valueAsStr = to_string(value);
            store_help_page_element(
                [this, config, description, valueAsStr, _tags = tags](std::string_view)
                {
                    auto tags = _tags;
 
                    // Check if validator is a file,directory,input and/or output paremeter
                    using Validator = std::decay_t<decltype(config.validator)>;
                    if constexpr (std::is_base_of_v<sharg::input_file_validator, Validator>)
                    {
                        tags.insert("file");
                    }
                    else if constexpr (std::is_base_of_v<sharg::input_directory_validator, Validator>)
                    {
                        tags.insert("directory");
                    }
                    else if constexpr (std::is_base_of_v<sharg::output_file_validator, Validator>)
                    {
                        tags.insert("file");
                        tags.insert("output");
                    }
                    else if constexpr (std::is_base_of_v<sharg::output_directory_validator, Validator>)
                    {
                        tags.insert("directory");
                        tags.insert("output");
                    }
 
                    info.params.push_back(tdl::Node{
                        .name = config.long_id,
                        .description = description,
                        .tags = std::move(tags),
                        .value = tdl::StringValue{valueAsStr},
                    });
                    info.cliMapping.emplace_back("--" + config.long_id, config.long_id);
                },
                config);
        }
        else
        {
            store_help_page_element(
                [this, config, value, description, tags](std::string_view)
                {
                    info.params.push_back(tdl::Node{
                        .name = config.long_id,
                        .description = description,
                        .tags = std::move(tags),
                        .value = to_tdl(value),
                    });
                    info.cliMapping.emplace_back("--" + config.long_id, config.long_id);
                },
                config);
        }
    }
 
    template <typename config_type>
    void add_flag(bool & value, config_type const & config)
    {
        store_help_page_element(
            [this, config, value](std::string_view)
            {
                info.params.push_back(tdl::Node{
                    .name = config.long_id,
                    .description = config.description,
                    .tags = {},
                    .value = to_tdl(value),
                });
            },
            config);
    }
 
    template <typename option_type, typename config_type>
    void add_positional_option(option_type & value, config_type const & config)
    {
        std::string msg = config.validator.get_help_page_message();
 
        positional_option_calls.push_back(
            [this, &value, config, msg](std::string_view)
            {
                auto id = "positional_" + std::to_string(positional_option_count);
                ++positional_option_count;
                auto description =
                    config.description +
                    // a list at the end may be empty and thus have a default value
                    ((detail::is_container_option<option_type>) ? detail::to_string(" Default: ", value, ". ")
                                                                : std::string{" "})
                    + msg;
 
                info.params.push_back(tdl::Node{
                    .name = id,
                    .description = description,
                    .tags = {},
                    .value = tdl::StringValue{},
                });
                if (!config.long_id.empty())
                {
                    info.cliMapping.emplace_back("--" + config.long_id, config.long_id);
                }
            });
    }
 
    void parse(parser_meta_data & parser_meta, std::vector<std::string> const & executable_name)
    {
        meta = parser_meta;
 
        // each call will evaluate the function print_list_item()
        for (auto f : positional_option_calls)
            f(meta.app_name);
 
        // each call will evaluate the function print_list_item()
        for (auto f : parser_set_up_calls)
            f(meta.app_name);
 
        info.metaInfo = tdl::MetaInfo{
            .version = meta.version,
            .name = meta.app_name,
            .docurl = meta.url,
            .category = "",
            .description = std::accumulate(begin(meta.description),
                                           end(meta.description),
                                           std::string{},
                                           [](auto a, auto v)
                                           {
                                               return a + v + '\n';
                                           }),
            //            .citations   = {meta.citation},
        };
        if (!executable_name.empty())
        {
            info.metaInfo.executableName = executable_name[0];
        }
        for (size_t i{1}; i < executable_name.size(); ++i)
        {
            auto name = "subcommand_" + std::to_string(i);
            info.params.push_back(tdl::Node{
                .name = name,
                .value = tdl::StringValue(executable_name[i]),
            });
            info.cliMapping.emplace_back("", name);
        }
 
        if (fileFormat == FileFormat::CTD)
        {
            std::cout << tdl::convertToCTD(info);
        }
        else if (fileFormat == FileFormat::CWL)
        {
            std::cout << tdl::convertToCWL(info) << "\n";
        }
        else
        {
            throw std::runtime_error("unsupported file format (this is a bug)");
        }
        std::exit(EXIT_SUCCESS); // program should not continue from here
    }
 
    void add_section(std::string const & SHARG_DOXYGEN_ONLY(title), bool const SHARG_DOXYGEN_ONLY(advanced_only))
    {}
 
    void add_subsection(std::string const & SHARG_DOXYGEN_ONLY(title), bool const SHARG_DOXYGEN_ONLY(advanced_only))
    {}
 
    void add_line(std::string const & SHARG_DOXYGEN_ONLY(text),
                  bool SHARG_DOXYGEN_ONLY(is_paragraph),
                  bool const SHARG_DOXYGEN_ONLY(advanced_only))
    {}
 
    void add_list_item(std::string const & SHARG_DOXYGEN_ONLY(key),
                       std::string const & SHARG_DOXYGEN_ONLY(desc),
                       bool const SHARG_DOXYGEN_ONLY(advanced_only))
    {}
 
private:
    void store_help_page_element(std::function<void(std::string_view)> printer, config<auto> const & config)
    {
        if (config.hidden)
            return;
        parser_set_up_calls.push_back(std::move(printer));
    }
};
 
} // namespace sharg::detail