appcli.cpp

//--------------------------------------------------------------------------------------------------
//  ALib C++ Framework
//  Configuration Sample
//
//  Copyright 2025 A-Worx GmbH, Germany
//  Published under Boost Software License (a free software license, see LICENSE.txt)
//--------------------------------------------------------------------------------------------------
#include "alib_precompile.hpp"
#if !defined(ALIB_C20_MODULES) || ((ALIB_C20_MODULES != 0) && (ALIB_C20_MODULES != 1))
#   error "Configuration MACRO ALIB_C20_MODULES has to be given to the compiler as either 0 or 1"
#endif
#if ALIB_C20_MODULES
    module;
#endif
 
//========================================= Global Fragment ========================================
#include "alib/strings/strings.prepro.hpp"
#include "alib/app/app.prepro.hpp"
#include "ALib.Monomem.StdContainers.H"
//============================================== Module ============================================
#if ALIB_C20_MODULES
    module ALib.App;
    import   ALib.App.Impl;
    import   ALib.Lang;
    import   ALib.Strings;
    import   ALib.Boxing;
    import   ALib.EnumRecords;
    import   ALib.EnumRecords.Bootstrap;
    import   ALib.Variables;
#else
#   include "ALib.Bootstrap.H"
#   include "ALib.Variables.Plugins.H"
#   include "ALib.App.CLI.H"
#endif
 
namespace alib::app {
 
AppCli::AppCli()
: App {&APPCLI_CAMP}  {
    machine.Program.AddBefore( App::States::ImportConfig     ,
                StateMachine::Command::MakeCustom<AppCli, &AppCli::bsCLIDefine>       (States::CLIDefine) );
 
    machine.Program.AddAfter(  States::CLIDefine     ,
                StateMachine::Command::MakeCustom<AppCli, &AppCli::bsCLIReadOptions>  (States::CLIReadOptions) );
 
    machine.Program.AddBefore( App::States::SetupALox          ,
                StateMachine::Command::MakeCustom<AppCli, &AppCli::bsReadDryRunOption>(States::ReadDryRunOption) );
 
    machine.Program.AddAfter ( App::States::ImportConfig,
                StateMachine::Command::MakeCustom<AppCli, &AppCli::bsConfigureCLI>    (States::ConfigureCLI) );
 
}
 
alib::Enum  AppCli::exceptionToExitCode( alib::Exception& exception ) {
    // check with parent
    Enum result= App::exceptionToExitCode(exception);
 
    // handle cli-exceptions
    if (   result == BuiltInExitCodes::ErrUnknown
        && exception.Type().IsEnumType<cli::Exceptions>() ) {
 
        // todo: gibt es diese method nicht bereits im CLIUtil?
        auto element= exception.Type().Get<cli::Exceptions>();
        for( auto& exitCodeDecl : cli.ExitCodeDecls )
            if( exitCodeDecl.second->AssociatedCLIException() == element ) {
                result= exitCodeDecl.first;
                break;
    }       }
 
    // also, we do not know. This is not good!
    
    return result;
}
 
 
 
void AppCli::onBsSetNameVersionAndInfo() {
    String infoFmtString= APPCLI_CAMP.GetResource("AppVersion");
    String128 buffer;
    ALIB_LOCK_RECURSIVE_WITH(alib::format::Formatter::DEFAULT_LOCK)
        Formatter::DEFAULT->Format( buffer, infoFmtString, alib::VERSION, alib::REVISION );
        appVersion= String(monomem::GLOBAL_ALLOCATOR, buffer);
 
    App::onBsSetNameVersionAndInfo();
}
 
void AppCli::bsCLIDefine() {
    cli.Init( &APPCLI_CAMP );
    cli.DefineExitCodes <ExitCodes >();
    cli.DefineParameters<Parameters>();
    cli.DefineCommands  <Commands  >();
    cli.DefineOptions   <Options   >();
}
 
void AppCli::bsCLIReadOptions()                                               { cli.ReadOptions(); }
 
void AppCli::bsConfigureCLI() {
    // set remaining cli args to configuration and allow shortcuts for cli variables
    variables::CLIVariablesPlugin* cliParameterPlugin=
                          APPCLI_CAMP.GetConfig()->GetPluginTypeSafe<variables::CLIVariablesPlugin>();
    for( auto& arg : cli.OptionArgsIgnored )
        cliParameterPlugin->AlternativeArgs.emplace_back( arg );
 
    cliParameterPlugin->DefaultCategories.emplace_back("ALIB");
    cliParameterPlugin->DefaultCategories.emplace_back("ALOX");
}
 
 
void AppCli::bsReadDryRunOption() {
    auto* dryOpt= cli.GetOption( Options::DryRun );
    if( dryOpt != nullptr ) {
        if( !CLIUtil::GetDryOpt( cli, *dryOpt ) ) {
            exitWithHelpOutput( ExitCodes::ErrBadParamValue,
                                dryOpt->Declaration->Identifier(),
                                dryOpt->Args.front() ,
                                dryOpt->Declaration->Identifier() );
            cliStop= true;
            return;
       }
 
        // with debug option "CLIDeclarations", we stop right now
        if( cli.DryRun == cli::DryRunModes::CLIDeclarations ) {
            CLIUtil::DumpDeclarations(cli, *cOut);
            machine.EmergencyStop= true;
}   }   }
 
 
void AppCli::onBsPreloadVariables() {
    App::onBsPreloadVariables();
    //AppCliCamp.GetConfig()->PreloadVariables<Variables>();
}
 
void AppCli::getConfigFilePaths(StdVectorMA<ConfigFileDescriptor>& files) {
    getConfigFilePathsFromCLIParam(files); if (machine.EmergencyStop) return;
    App::getConfigFilePaths(files);
}
 
void AppCli::getConfigFilePathsFromCLIParam(StdVectorMA<ConfigFileDescriptor>& files) {
 
    auto* optionConfig= cli.GetOption(Options::Config);
    if( optionConfig == nullptr )
        return;
 
    Substring names=  optionConfig->Args.front();
    size_t cnt= 0;
    while (names.IsNotEmpty()) {
        Substring name= names.ConsumeToken(',');
        name.Trim();
        if (files.size() <= cnt)
            files.emplace_back();
        Path& path= files.at(cnt).Pathname;
        if(    !name.IsEmpty()
            && !String("Default").StartsWith<CHK,lang::Case::Ignore>( name ) )
            path.Reset(name);
        ++cnt;
    }
    return;
}
 
//==================================================================================================
// Run
//==================================================================================================
void AppCli::onRunStart() {
    if ( cliStop )
        return;
    
    // if 'dryrun' was recognized, output resource "DryRunStart"
    // todo: This has to be doxed: A user can add a resource here.
    String resource= APPCLI_CAMP.TryResource( "AppStart" );
    if ( resource.IsNotEmpty() )
        cOut->AddMarked( resource, GetName(), GetVersion() );
 
    if( cli.DryRun == cli::DryRunModes::Application ) {
        resource= APPCLI_CAMP.TryResource( "DryRunStart" );
        if ( resource.IsNotEmpty() )
            cOut->AddMarked( resource, appName );
    }
 
    //------- check for option 'help' -------
    cli::Option* option= cli.GetOption( Options::Help);
    if( option ) {
        if( !CLIUtil::GetHelp( cli, option, *cOut ) )
            exitWithHelpOutput( ExitCodes::ErrBadParamValue,
                                option->Declaration->Identifier(),
                                option->Args.front(),
                                option->Declaration->Identifier() );
        cliStop= true;
        return;
}   }
 
void AppCli::exitWithHelpOutput( Enum exitCode, const String& helpTopic, Box fp1, Box fp2 ) {
    cErr->Add( cli.ExitCodeDecls.Find(exitCode).Mapped()->FormatString(), fp1, fp2,
               APPCLI_CAMP.GetResource("USAGEFOLLOWS") );
    cErr->Buffer << NEW_LINE;
    onSdOutput();
    CLIUtil::GetHelp( cli, helpTopic, *cOut );
    machine.SetExitCode(exitCode);
}
 
void AppCli::onRun() {
    if ( cliStop )
        return;
 
    cli.ReadNextCommands();
 
    //------- No command recognized? This is allowed, calls cliProcessCmd with nullptr -------
    if( cli.CommandsParsed.size() == 0 ) {
        // No command. If derived does not process no-commands, then throw.
        if (!cliProcessCmd(nullptr) )
            exitWithHelpOutput(ExitCodes::ErrNoCmdGiven);
        
        // Still an argument was left? This is not allowed
        if( cli.ArgsLeft.size() > 0 ) {
            exitWithHelpOutput(ExitCodes::ErrUnknownCommand, NULL_STRING,
                                ARG_VN[cli.ArgsLeft.front() + 1]);
            return;
        }
 
        return;
    }
 
    //------- Command loop -------
    // Note: Making a loop here is optional. We do it to allow multiple commands
    //       with one invocation of the application.
    cli::Command* actCmd;
    while ( !cliStop && (actCmd= cli.NextCommand()) != nullptr ) {
        ALIB_DBG( bool processed= )
        cliProcessCmd(actCmd);
        ALIB_ASSERT_ERROR(processed, "APP",
            "Command \"{}\" recognized but not processed by the App.",
            actCmd->Declaration->Identifier() )
}   }
 
void AppCli::onRunEnd() {
    if ( cliStop )
        return;
    
    // if 'dryrun' was recognized, output resource "DryRunEnd"
    if( cli.DryRun == cli::DryRunModes::Application ) {
        String dryRunEnd= APPCLI_CAMP.TryResource( "DryRunEnd" );
        if ( dryRunEnd.IsNotEmpty() )
            cOut->AddMarked( dryRunEnd );
}   }
 
 
bool AppCli::cliProcessCmd(cli::Command* cmd) {
    if ( cmd == nullptr )
        return false;
 
    if( cmd->Declaration->Element() == Commands::Help )  {
        if( !CLIUtil::GetHelp( cli, cmd, *cOut ) ) {
            // Assert that one argument was consumed as the help topic.
            // No other circumstance could make GetHelp fail.
            ALIB_ASSERT(cmd->ConsumedArguments== 2, "APP") // 2 means the command and the argument
            exitWithHelpOutput( ExitCodes::ErrBadParamValue, cmd->Declaration->Identifier(),
                                ARG_VN[cmd->Position + 2], cmd->Declaration->Identifier()  );
        }
        cliStop= true;
        return true;
    }
 
    return false;
}
 
 
 
 
} // namespace [alib::app]