cli_app.h

/*
 * Copyright 2025 Dominik Czekai
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include "cli_config.h"
#include "commands/command_tree.h"
#include "commands/docwriting/docwriting.h"
#include "logging/logger.h"
#include "parsing/parser.h"
 
#define RUN_CLI_APP(cliInstance, argc_, argv_)                                                     \
    try                                                                                            \
    {                                                                                              \
        return cliInstance.run(argc_, argv_);                                                      \
    }                                                                                              \
    catch (const std::exception &e)                                                                \
    {                                                                                              \
        cliInstance.Logger().error() << e.what() << std::endl;                                     \
        std::abort();                                                                              \
    }
 
namespace cli
{
class CliApp
{
public:
    // Non-copyable
    CliApp(const CliApp &) = delete;
    CliApp &operator=(const CliApp &) = delete;
 
    explicit CliApp(std::string_view executableName);
    explicit CliApp(CliConfig &&config);
    explicit CliApp(const CliConfig &config, std::unique_ptr<logging::AbstractLogger> logger);
    ~CliApp() = default;
 
    CliApp &withCommand(std::unique_ptr<commands::Command> subCommandPtr);
 
    CliApp &withCommand(commands::Command &&subCommand);
 
    void init();
 
    int run(int argc, char *argv[]);
 
    [[nodiscard]] logging::AbstractLogger &Logger() { return *logger; }
 
    [[nodiscard]] const commands::CommandTree &getCommandTree() const { return commandsTree; };
 
    [[nodiscard]] commands::Command *getMainCommand() { return commandsTree.getRootCommand(); };
 
    [[nodiscard]] CliConfig &getConfig() { return *configuration; };
 
    [[nodiscard]] commands::docwriting::DocWriter &getDocWriter() { return docWriter; }
 
    void setLogger(std::unique_ptr<logging::Logger> &&newLogger) { logger = std::move(newLogger); }
 
private:
    int internalRun(std::span<char *const> args);
    bool rootShortCircuits(std::vector<std::string> &args, const cli::commands::Command &cmd) const;
    bool commandShortCircuits(std::vector<std::string> &args, const cli::commands::Command *cmd) const;
    bool initialized{false};
    commands::CommandTree commandsTree;
 
    std::unique_ptr<CliConfig> configuration;
    std::unique_ptr<logging::AbstractLogger> logger;
 
    parsing::Parser parser;
    cli::commands::docwriting::DocWriter docWriter;
};
} // namespace cli