simple_project_generator.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : LGPL-3.0-only
****************************************/
 
#include <ctime>
 
#include "directory_replace_placeholder.h"
#include "simple_project_generator.h"
#include "parserClassConfig.h"
#include "gitlab_doc.h"
 
//C++ Trait Backend
#include "CppTraitFromString.h"
#include "CppTraitSetter.h"
#include "CppTraitGetter.h"
#include "CppTraitCopy.h"
#include "CppTraitTypeStream.h"
#include "CppTraitDataStream.h"
#include "CppTraitConfigStream.h"
#include "CppTraitCheckStream.h"
 
#include "PTraitBackendManager.h"
 
//Wrapper Trait Backend
#include "WrapperTraitGetterSetter.h"
#include "WrapperTraitTypeStream.h"
#include "WrapperTraitDataStream.h"
#include "PWrapperTraitBackendManager.h"
 
//Nanobind Trait Backend
#include "NanobindTraitProperty.h"
#include "NanobindTraitMethod.h"
#include "NanobindTraitTypeStream.h"
#include "NanobindTraitDataStream.h"
#include "NanobindTraitCheckStream.h"
#include "NanobindTraitTestSetup.h"
#include "NanobindTraitInclude.h"
#include "PNanobindTraitBackendManager.h"
 
//Rust Trait Backend
#include "RustTraitGetterSetter.h"
#include "PRustTraitBackendManager.h"
 
//C++ Generator
#include "generator_class_cpp.h"
//Wrapper Generator
#include "wrapper_generator_struct.h"
//Nanobind Generator
#include "nanobind_generator.h"
//Rust Generator
#include "generator_class_rust.h"
 
#include "simpleClassGenerator.h"


bool isPhoenixDependency(const PString & packageName){
        return (packageName.isSameBegining("Phoenix") || packageName.isSameBegining("phoenix"));
}


PString generateCmakeFindBody(const ProjectConfig & projectConfig){
        PString cmakeFindBody;
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(!isPhoenixDependency(pkgAttr.getName())){
                        if(!pkgAttr.getCmakeFind().empty()){
                                cmakeFindBody += "find_package("+pkgAttr.getCmakeFind()+")";
                        }
                } 
        }
        return cmakeFindBody;
}


PString generatePhoenixPullExtraModule(const ProjectConfig & projectConfig){
        PString phoenixPullExtraModule;
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(isPhoenixDependency(pkgAttr.getName())){
                        phoenixPullExtraModule += "pull_extra_module(\""+pkgAttr.getName()+"\" \""+pkgAttr.getUrl()+"\")\n";
                }
        }
        return phoenixPullExtraModule;
}


PString generatePhoenixFindModule(const ProjectConfig & projectConfig){
        PString phoenixFindModule;
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(isPhoenixDependency(pkgAttr.getName())){
                        phoenixFindModule += " "+pkgAttr.getName();
                }
        }
        return phoenixFindModule;
}


PString generatePhoenixGlobalDep(const ProjectConfig & projectConfig){
        PString phoenixGlobalDep;
        phoenixGlobalDep += "set(" + projectConfig.name.toUpper() + "_TEST_DEPENDENCIES\n";
        phoenixGlobalDep += "\t" + projectConfig.name.toSnakeCase() + "\n";
        for(PackageMap::const_reverse_iterator depIt = projectConfig.mapDependencies.rbegin(); depIt != projectConfig.mapDependencies.rend(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(isPhoenixDependency(pkgAttr.getName())){
                        phoenixGlobalDep += "\t"+pkgAttr.getCmakeLib()+"\n";
                }
        }
        phoenixGlobalDep += ")";
        return phoenixGlobalDep;
}


PString generateTargetLinkBody(const ProjectConfig & projectConfig){
        PString targetLinkBody;
        targetLinkBody += "target_link_libraries("+projectConfig.name.toSnakeCase()+" ";
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(!isPhoenixDependency(pkgAttr.getName())){
                        targetLinkBody += pkgAttr.getCmakeLib()+" ";
                } 
        }
        // Add Phoenix dependencies (to ensure proper linking even if phoenix_create_find should handle it)
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(isPhoenixDependency(pkgAttr.getName())){
                        targetLinkBody += pkgAttr.getCmakeLib()+" ";
                }
        }
        targetLinkBody += ")\n";
        return targetLinkBody;
}


PString generatePixiBody(const ProjectConfig & projectConfig){
        PString pixiBody;
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                PString pixi_name = pkgAttr.getPixiName().toLower();
                PString min_version = pkgAttr.getMinVersion();
                PString max_version = pkgAttr.getMaxVersion();
                if(pixi_name == "") continue;
                else if(min_version.empty() && max_version.empty()){
                        pixiBody += pixi_name + " = \"*\"\n";
                }else if(max_version.empty()){
                        pixiBody += pixi_name + " = \"" + min_version + "\"\n";
                }else{
                        pixiBody += pixi_name + " = \"" + min_version;
                        if(!min_version.empty() && !max_version.empty()) pixiBody += ",";
                        pixiBody += max_version + "\"\n";
                }
        }
        return pixiBody;
}


PString generateMarkdownDepList(const ProjectConfig & projectConfig){
        PString packageMdList;
        for(PackageMap::const_iterator depIt = projectConfig.mapDependencies.begin(); depIt != projectConfig.mapDependencies.end(); ++depIt){
                const PPackageAttribute & pkgAttr = depIt->second;
                if(isPhoenixDependency(pkgAttr.getName())){
                        packageMdList += "- ["+pkgAttr.getName()+"]("+pkgAttr.getUrl()+")\n";
                }
        }
        return packageMdList;
}


PString generateAuthorListPixi(const ProjectConfig & projectConfig){
        PString authorListPixi;
        authorListPixi += "authors = [\n";
        for(ProjectMembersMap::const_iterator it = projectConfig.authorMap.begin(); it != projectConfig.authorMap.end(); ++it){
                const PProjectMembers & author = it->second;
                authorListPixi += "     \"" + author.getFirstName() + " " + author.getLastName() + " <" + author.getEmail() + ">\",\n";
        }
        authorListPixi += "]\n";
        return authorListPixi;
}


PString generateNanobindCmakeSources(const ProjectConfig & projectConfig, const PVecPath & vecClassConfigFile, const GeneratorMode & mode){
        PString nanobindSources;
        nanobindSources += "# We are now ready to compile the actual extension module\n";
 
        for(const PPath & classConfigFile : vecClassConfigFile){
                PPath baseFileName = classConfigFile.getFileName().eraseExtension();
                PString bindingSource = baseFileName + "_binding.cpp";
                PString fileModuleName = baseFileName.toLower();
                
                nanobindSources += "nanobind_add_module(\n";
                nanobindSources += "\t" + fileModuleName + "          # Name of the module\n";
                nanobindSources += "\tSTABLE_ABI                   # Compatible Python 3.12+ stable ABI\n";
                nanobindSources += "\tNB_STATIC                    # Static linking\n";
                nanobindSources += "\tLTO                          # Link-time optimization\n";
                nanobindSources += "\t" + bindingSource + "     # Source file\n";
                nanobindSources += ")\n";
                nanobindSources += "target_link_libraries(" + fileModuleName + " PRIVATE " + projectConfig.name.toSnakeCase() + ")\n";
                nanobindSources += "install(TARGETS " + fileModuleName + " LIBRARY DESTINATION ${PYTHON_SITE_PACKAGES} ARCHIVE DESTINATION ${PYTHON_SITE_PACKAGES})\n\n";
        }
 
        return nanobindSources;
}


PString generateRustModuleDeclarations(const PVecPath & vecClassConfigFile){
        PString decls;
        for(const PPath & classConfigFile : vecClassConfigFile){
                decls += "pub mod " + classConfigFile.getFileName().eraseExtension().toSnakeCase() + ";\n";
        }
        return decls;
}


PMapString generateReplacementMap(const ProjectConfig & projectConfig, const GeneratorMode & mode, const PString & cmakeFindBody, const PString & phoenixPullExtraModule,
                                const PString & phoenixFindModule, const PString & phoenixGlobalDep, const PString & targetLinkBody,
                                const PString & pixiBody, const PString & markdownDepList, const PString & authorListPixi, const PString & nanobindCMakeSources,
                                const PString & rustModuleDeclarations)
{
        PMapString mapReplace;
        if(mode.type == ProjectType::NANOBIND_WRAPPER){
                mapReplace["xxxnanobind_sourcesxxx"] = nanobindCMakeSources;                                    //nanobind cmake sources
        }
        if(mode.type == ProjectType::RUST){
                mapReplace["XXXRustModuleDeclarationsXXX"] = rustModuleDeclarations;                            //rust module declarations for lib.rs
        }
        mapReplace["XXXProjectNameXXX"] = projectConfig.name;                                                   //project name
        mapReplace["XXXPROJECT_NAMEXXX"] = projectConfig.name.toUpper();                                        //project name uppercase
        mapReplace["xxxproject_namexxx"] = projectConfig.name.toSnakeCase();                                    //project library
        mapReplace["XXXProjectNameDescriptionXXX"] = projectConfig.description;                                 //description
        mapReplace["XXXProjectNameUrlXXX"] = projectConfig.url;                                                 //project url
        mapReplace["XXXProjectVersionXXX"] = projectConfig.version;                                             //project version
        mapReplace["XXXProjectNameHomepageUrlXXX"] = projectConfig.url;                                         //project doc url (TODO add it or deduce it from the project url for gitlab)
        mapReplace["XXXProjectNameRunnerTagXXX"] = projectConfig.runnerTag;                                     //Project CI runner tag
        mapReplace["XXXProjectFindPackageDependenciesXXX"] = cmakeFindBody;                                     //project find_package
        mapReplace["XXXProjectPhoenixDependenciesXXX"] = phoenixPullExtraModule;                                //project pull_extra_module
        mapReplace["XXXProjectNameCMakeFindDependenciesXXX"] = phoenixFindModule;                               //project dependencies of phoenix_create_find
        mapReplace["XXXProjectDependenciesCMakeVarXXX"] = phoenixGlobalDep;                                     //cmake variable to hold test dependencies
        mapReplace["XXXProjectNameTargetLinkLibDependenciesXXX"] = targetLinkBody;                              //full target_link_library command of generated lib
        mapReplace["XXXCxxWorkflowUrlXXX"] = projectConfig.ciToolkitUrl+"@"+projectConfig.ciToolkitVersion;     //Url and version of the CI workflow
        mapReplace["XXXGitlabPagesUrlXXX"] = getGitlabDocUrl(projectConfig.url);                                                                //group to which the project belongs to
        mapReplace["xxxphoenixprojectpixipackagenamexxx"] = projectConfig.name.toLower();                       //name of the pixi package
        mapReplace["xxxprojectnamepixiextradependenciesxxx"] = pixiBody;                                        //extra pixi dependencies
        mapReplace["XXXProjectNameMarkdownListDependenciesXXX"] = markdownDepList;                              //markdown list of Phoenix dependencies
        mapReplace["XXXProjectAuthorListPixiXXX"] = authorListPixi;                                             //author list for pixi.toml
        return mapReplace;
}


PMapString generateAllReplacementData(const ProjectConfig & projectConfig, const GeneratorMode & mode, const PVecPath & vecClassConfigFile){
        // Generate various bodies using dedicated functions
        PString cmakeFindBody = generateCmakeFindBody(projectConfig);
        PString phoenixPullExtraModule = generatePhoenixPullExtraModule(projectConfig);
        PString phoenixFindModule = generatePhoenixFindModule(projectConfig);
        PString phoenixGlobalDep = generatePhoenixGlobalDep(projectConfig);
        PString targetLinkBody = generateTargetLinkBody(projectConfig);
        PString pixiBody = generatePixiBody(projectConfig);
        PString markdownDepList = generateMarkdownDepList(projectConfig);
        PString authorListPixi = generateAuthorListPixi(projectConfig);
        PString nanobindCMakeSources;
        if(mode.type == ProjectType::NANOBIND_WRAPPER){
                nanobindCMakeSources = generateNanobindCmakeSources(projectConfig, vecClassConfigFile, mode);
        }
        PString rustModuleDeclarations;
        if(mode.type == ProjectType::RUST){
                rustModuleDeclarations = generateRustModuleDeclarations(vecClassConfigFile);
        }
 
        time_t timestamp;
        PString dateStr = ctime(&(timestamp = time(nullptr)));
        dateStr = dateStr.eraseLastChar("\n"); // Remove the trailing \n
 
        // Generate the replacement map
        return generateReplacementMap(projectConfig, mode, cmakeFindBody, phoenixPullExtraModule,
                                phoenixFindModule, phoenixGlobalDep, targetLinkBody,
                                pixiBody, markdownDepList, authorListPixi, nanobindCMakeSources, rustModuleDeclarations);
}


bool simple_project_load_config(ProjectParam & param, const PPath & pdataDir, const PVecPath & vecClassConfigFile){
        bool b(true);
        for(const PPath & classConfigFile : vecClassConfigFile){
                PDataConfig dataConfig;
                dataConfig.getFileName() = classConfigFile;
                if(!parserClassConfig(dataConfig.getVecClassConfig(), dataConfig.getVecInclude(), classConfigFile)){
                        std::cerr << "simple_project_load_config : can't load file '" << classConfigFile << "'" << std::endl;
                        b = false;      //Best effort strategy
                }
                param.vecDataConfig.push_back(dataConfig);
                
                PPath destFile = pdataDir / classConfigFile.getFileName();
                PString fileContent = classConfigFile.loadFileContent();
                if(!destFile.saveFileContent(fileContent)){
                        std::cerr << "simple_project_load_config : cannot copy pdata file to project pdata directory '"<<destFile<<"'" << std::endl;
                        b = false;      //Best effort strategy
                }
        }
        return b;
}


bool generateCppClassesFull(const ProjectParam & projectParam){
        PTraitBackendManager manager;
        manager.addTraitBackend<CppTraitFromString>();
        manager.addTraitBackend<CppTraitCopy>();
        manager.addTraitBackend<CppTraitSetter>();
        manager.addTraitBackend<CppTraitGetter>();
        manager.addTraitBackend<CppTraitTypeStream>();
        manager.addTraitBackend<CppTraitDataStream>();
        manager.addTraitBackend<CppTraitConfigStream>();
        manager.addTraitBackend<CppTraitCheckStream>();
        return generator_class_full(manager, projectParam);
}


bool generateWrapperClassesFull(const ProjectParam & projectParam){
        PWrapperTraitBackendManager manager;
        manager.addTraitBackend<WrapperTraitGetterSetter>();
        manager.addTraitBackend<WrapperTraitTypeStream>();
        manager.addTraitBackend<WrapperTraitDataStream>();
        return wrapper_generator_class_full(manager, projectParam);
}


bool generateNanobindClassesFull(const ProjectParam & projectParam){
        PNanobindTraitBackendManager manager;
        manager.addTraitBackend<NanobindTraitProperty>();
        manager.addTraitBackend<NanobindTraitMethod>();
        manager.addTraitBackend<NanobindTraitTypeStream>();
        manager.addTraitBackend<NanobindTraitDataStream>();
        manager.addTraitBackend<NanobindTraitCheckStream>();
        manager.addTraitBackend<NanobindTraitTestSetup>();
        manager.addTraitBackend<NanobindTraitInclude>();
        return generator_nanobind_full(manager, projectParam);
}
 


bool generateRustClassesFull(const ProjectParam & projectParam){
        ProjectParam updatedParam(projectParam);
        updatedParam.mode.moduleName = updatedParam.name.toLower();     //Cargo crate name, matches xxxphoenixprojectpixipackagenamexxx
        PRustTraitBackendManager manager;
        manager.addTraitBackend<RustTraitGetterSetter>();
        return generator_rust_class_full(manager, updatedParam);
}


ProjectParam stripNanobindUnsupportedType(const ProjectParam & projectParam){
        ProjectParam output(projectParam);
        PVecDataConfig & vecConfig = output.vecDataConfig;
        for(PVecDataConfig::iterator itConfig(vecConfig.begin()); itConfig != vecConfig.end(); ++itConfig){
                PVecClassConfig & vecClass = itConfig->getVecClassConfig();
                for(PVecClassConfig::iterator itClass(vecClass.begin()); itClass != vecClass.end(); ++itClass){
                        PVecClassAttribute & vecAttr = itClass->getListAttribute();
                        for(PVecClassAttribute::iterator itAttr(vecAttr.begin()); itAttr != vecAttr.end(); ++itAttr){
                                PString name = itAttr->getType();
                                itAttr->setType(name.replace("PPath", "std::string").replace("PString", "std::string"));
                        }
                }
        }
        return output;
}


bool simple_project_generate_source(const ProjectParam & projectParam){
        switch(projectParam.mode.type){
                case ProjectType::CPP:
                        return generateCppClassesFull(projectParam);
                case ProjectType::WRAPPER:
                        return generateWrapperClassesFull(projectParam);
                case ProjectType::NANOBIND_WRAPPER:
                        {
                                ProjectParam strip(stripNanobindUnsupportedType(projectParam));
                                return generateCppClassesFull(strip) && generateNanobindClassesFull(strip);
                        }
                case ProjectType::RUST:
                        return generateRustClassesFull(projectParam);
                default:
                        return false;
        }
}


bool simple_project_generator(const PPath & descriptionFile, const PVecPath & vecClassConfigFile, const PString & projectType,
                        const GeneratorMode & mode)
{
        //First, let's read the toml config of the project
        ProjectConfig projectConfig;
        if(!project_generator_loadConfig(projectConfig, descriptionFile)){
                std::cerr << "simple_project_generator : cannot parse project description file '"<<descriptionFile<<"'" << std::endl;
                return false;
        }
        //Then look in the config files if the packages exists
        if(!project_generator_loadPackageInfo(projectConfig)){
                std::cerr << "simple_project_generator : cannot find package info of project '"<<projectConfig.name<<"'" << std::endl;
                return false;
        }
        // Generate replacement data
        PMapString mapReplace = generateAllReplacementData(projectConfig, mode, vecClassConfigFile);
        PPath inputConfigPlaceholderDir = PPath::getProgramPrefix() / PPath("share") / PPath("PhoenixGenerator") / PPath("Projects") / PPath(projectType), outputPath("./");
        if(!directory_replace_placeholder(outputPath, inputConfigPlaceholderDir, mapReplace)){
                std::cerr << "simple_project_generator : cannot replace placeholder in project generation '"<<projectConfig.name<<"'" << std::endl;
                return false;
        }
        PPath mainPath = PPath(".") / PPath(projectConfig.name);
        PPath srcPath = mainPath / PPath("src"), pdataDir = mainPath / PPath("pdata");
        if(!pdataDir.createDirectory()){
                std::cerr << "simple_project_generator : cannot create pdata directory '"<<pdataDir<<"'" << std::endl;
                return false;
        }
        ProjectParam param;
        param.mode = mode;
        param.name = projectConfig.name;
        param.version = projectConfig.version;
        param.outputProjectDir = mainPath;
        param.outputSourceDir = srcPath;
        if(param.mode.type == ProjectType::CPP || param.mode.type == ProjectType::NANOBIND_WRAPPER){
                param.outputTestDir = mainPath / PPath("TESTS");
        }else if(param.mode.type == ProjectType::WRAPPER || param.mode.type == ProjectType::RUST){
                param.outputTestDir = mainPath / PPath("tests");
        }
        
        if(!simple_project_load_config(param, pdataDir, vecClassConfigFile)){
                std::cerr << "simple_project_generator : cannot load config to generate project in '"<<srcPath<<"'" << std::endl;
                return false;
        }
        if(!simple_project_generate_source(param)){
                std::cerr << "simple_project_generator : cannot generate sources in '"<<srcPath<<"'" << std::endl;
                return false;
        }
        // Generate class generator script
        if(!generateClassGeneratorScript(vecClassConfigFile, pdataDir, param.mode)){
                std::cerr << "simple_project_generator : cannot generate class generator script in pdata directory '"<<pdataDir<<"'" << std::endl;
                return false;
        }
        return true;
}