simple_project_generator.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <ctime>
 
#include "directory_replace_placeholder.h"
#include "simple_project_generator.h"
#include "parserClassConfig.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"
 
//C++ Generator
#include "generator_class_cpp.h"
//Wrapper Generator
#include "wrapper_generator_struct.h"
//Nanobind Generator
#include "nanobind_generator.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 generateProjectAuthorList(const ProjectConfig & projectConfig){
        PString projectAuthorList;
        bool firstAuthor = true;
        for(ProjectMembersMap::const_iterator it = projectConfig.authorMap.begin(); it != projectConfig.authorMap.end(); ++it){
                const PProjectMembers & author = it->second;
                if(!firstAuthor) projectAuthorList += ",\n";
                projectAuthorList += "          {\n";
                projectAuthorList += "                  \"@type\": \"Person\",\n";
                projectAuthorList += "                  \"givenName\": \"" + author.getFirstName() + "\",\n";
                projectAuthorList += "                  \"familyName\": \"" + author.getLastName() + "\",\n";
                projectAuthorList += "                  \"email\": \"" + author.getEmail() + "\",\n";
                projectAuthorList += "                  \"affiliation\": {\n";
                projectAuthorList += "                          \"@type\": \"Organization\",\n";
                projectAuthorList += "                          \"name\": \"" + author.getAffiliation() + "\"\n";
                projectAuthorList += "                  }\n";
                projectAuthorList += "          }";
                firstAuthor = false;
        }
        return projectAuthorList;
}


PString generateProjectContributorList(const ProjectConfig & projectConfig){
        PString projectContributorList;
        bool firstContributor = true;
        for(ProjectMembersMap::const_iterator it = projectConfig.contributorMap.begin(); it != projectConfig.contributorMap.end(); ++it){
                const PProjectMembers & contributor = it->second;
                if(!firstContributor) projectContributorList += ",\n";
                projectContributorList += "             {\n";
                projectContributorList += "                     \"@type\": \"Person\",\n";
                projectContributorList += "                     \"givenName\": \"" + contributor.getFirstName() + "\",\n";
                projectContributorList += "                     \"familyName\": \"" + contributor.getLastName() + "\",\n";
                projectContributorList += "                     \"email\": \"" + contributor.getEmail() + "\",\n";
                projectContributorList += "                     \"affiliation\": {\n";
                projectContributorList += "                             \"@type\": \"Organization\",\n";
                projectContributorList += "                             \"name\": \"" + contributor.getAffiliation() + "\"\n";
                projectContributorList += "                     }\n";
                projectContributorList += "             }";
                firstContributor = false;
        }
        return projectContributorList;
}


PString generateMaintainer(const ProjectConfig & projectConfig){
        PString maintainer;
        const PProjectMembers & maintainerPerson = projectConfig.maintainerMap.begin()->second;
        maintainer += "         \"@type\": \"Person\",\n";
        maintainer += "         \"givenName\": \"" + maintainerPerson.getFirstName() + "\",\n";
        maintainer += "         \"familyName\": \"" + maintainerPerson.getLastName() + "\",\n";
        maintainer += "         \"email\": \"" + maintainerPerson.getEmail() + "\",\n";
        maintainer += "         \"affiliation\": {\n";
        maintainer += "                 \"@type\": \"Organization\",\n";
        maintainer += "                 \"name\": \"" + maintainerPerson.getAffiliation() + "\"\n";
        maintainer += "         }";
        return maintainer;
}


PString generateKeywordsBody(const ProjectConfig & projectConfig){
        PString keywordsBody;
        if(!projectConfig.keywordList.empty()){
                bool firstKeyword = true;
                for(std::vector<PString>::const_iterator it = projectConfig.keywordList.begin(); it != projectConfig.keywordList.end(); ++it){
                        if(!firstKeyword) keywordsBody += ",\n";
                        keywordsBody += "               \"" + *it + "\"";
                        firstKeyword = false;
                }
        }
        return keywordsBody;
}


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() + "_module";
                
                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 ${LIBRARY_DIRECTORY} ARCHIVE DESTINATION ${LIBRARY_DIRECTORY})\n\n";
        }
 
        return nanobindSources;
}


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 & projectAuthorList, const PString & projectContributorList, const PString & maintainer,
                                const PString & keywordsBody, const PString & dateStr, const PString & nanobindCMakeSources)
{
        PMapString mapReplace;
        if(mode.type == ProjectType::NANOBIND_WRAPPER){
                mapReplace["xxxnanobind_sourcesxxx"] = nanobindCMakeSources;                                    //nanobind cmake sources
        }
        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["XXXProjectNameTargetLinkLinDependenciesXXX"] = targetLinkBody;                              //full target_link_library command of generated lib
        mapReplace["XXXCxxWorkflowUrlXXX"] = projectConfig.ciToolkitUrl+"@"+projectConfig.ciToolkitVersion; //Url and version of the CI workflow
        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["XXXcreationDateXXX"] = dateStr;                                                             //creation date
        mapReplace["XXXProjectAuthorListPixiXXX"] = authorListPixi;                                             //author list for pixi.toml
        mapReplace["XXXAuthorListXXX"] = projectAuthorList;                                                     //author list for codemeta.json
        mapReplace["XXXContributorListXXX"] = projectContributorList;                                           //contributor list for codemeta.json
        mapReplace["XXXMaintainerXXX"] = maintainer;                                                            //maintainer for codemeta.json
        mapReplace["XXXKeywordListsXXX"] = keywordsBody;                                                        //keyword list for codemeta.json
        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 projectAuthorList = generateProjectAuthorList(projectConfig);
        PString projectContributorList = generateProjectContributorList(projectConfig);
        PString maintainer = generateMaintainer(projectConfig);
        PString keywordsBody = generateKeywordsBody(projectConfig);
        PString nanobindCMakeSources;
        if(mode.type == ProjectType::NANOBIND_WRAPPER){
                nanobindCMakeSources = generateNanobindCmakeSources(projectConfig, vecClassConfigFile, mode);
        }
 
        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, projectAuthorList,
                                projectContributorList, maintainer, keywordsBody, dateStr, nanobindCMakeSources);
}


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 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:
                        return generateCppClassesFull(projectParam) && generateNanobindClassesFull(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(SYSTEM_INSTALL_DIR) / 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.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;
}