project_generator_load.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : LGPL-3.0-only
****************************************/
 
#include "phoenix_color.h"
#include "parser_toml.h"
#include "project_generator_load.h"


bool project_generator_split_dependencies(ProjectConfig & config, std::vector<PString> & vecDependencies){
        for(const PString & depStr : vecDependencies){
                PString name(""), min_version(""), max_version("");
                std::istringstream iss(depStr);
                std::vector<PString> depValues;
                PString token;
                while (iss >> token){depValues.push_back(token);}
                if(!depValues.empty()){
                        name = depValues[0];
                        for(size_t i=1; i<depValues.size(); ++i){
                                if(depValues[i].isSameBegining("==")) {
                                        // User specifies the exact version
                                        min_version = depValues[i];
                                        max_version = "";
                                        break;
                                }
                                if(depValues[i].isSameBegining(">=") || depValues[i].isSameBegining(">")) {
                                        min_version = depValues[i];
                                        if(!min_version.empty() && min_version.back() == ',') min_version.pop_back();
                                }
                                if(depValues[i].isSameBegining("<=") || depValues[i].isSameBegining("<")) {
                                        max_version = depValues[i];
                                        if(!max_version.empty() && max_version.back() == ',') max_version.pop_back();
                                }
                        }
                }else{
                        name = depStr;
                }
                // Fill the matching attributes
                config.mapDependencies[name].setName(name);
                config.mapDependencies[name].setMinVersion(min_version);
                config.mapDependencies[name].setMaxVersion(max_version);
        }
        return true;
}


bool parseProjectMembers(ProjectMembersMap & memberMap, const DicoValue * memberDico){
        if(memberDico == NULL || !memberDico->hasVec()){
                return false;
        }
        const std::vector<DicoValue> & vecMember = memberDico->getVecChild();
        for(size_t iMember = 0; iMember < vecMember.size(); iMember++){
                const DicoValue & memberData = vecMember[iMember];
                if(memberData.hasMap()){
                        PProjectMembers member;
                        member.setLastName(phoenix_get_string(memberData, "lastName", ""));
                        member.setFirstName(phoenix_get_string(memberData, "firstName", ""));
                        member.setAffiliation(phoenix_get_string(memberData, "affiliation", ""));
                        member.setEmail(phoenix_get_string(memberData, "mail", ""));
                        
                        // Use lastName + firstName as key to handle duplicate lastNames
                        PString key = member.getLastName() + "_" + member.getFirstName();
                        memberMap[key] = member;
                }
        }
        return true;
}


bool project_generator_loadConfig(ProjectConfig & config, const PPath & descriptionFile){
        DicoValue dico;
        if(!parser_toml(dico, descriptionFile)){
                std::cerr << termRed() << "project_generator_loadConfig : cannot parse config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                return false;
        }
        DicoValue * mapProject = dico.getMap("project");
        if(mapProject == NULL){
                std::cerr << termRed() << "project_generator_loadConfig : Missing [project] in config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                return false;
        }
        const PVecString vecRequiredKey{"name", "url", "version", "description", "main_branch", "ci_toolkit_version", "ci_toolkit_url", "authors"};
        PVecString vecMissingKey;
        for(const PString & requiredKey : vecRequiredKey){
                if(!mapProject->isKeyExist(requiredKey)){
                        vecMissingKey.push_back(requiredKey);
                }
        }
        if(!vecMissingKey.empty()){
                std::cerr << termRed() << "project_generator_loadConfig : missing required attribute(s) in [project] of config file '"<<descriptionFile<<"' : ";
                for(size_t iMissingKey = 0LU; iMissingKey < vecMissingKey.size(); ++iMissingKey){
                        if(iMissingKey != 0LU){std::cerr << ", ";}
                        std::cerr << vecMissingKey[iMissingKey];
                }
                std::cerr << termDefault() << std::endl;
                return false;
        }
        config.name = phoenix_get_string(*mapProject, "name", "MyAwesomeProject");
        config.url = phoenix_get_string(*mapProject, "url", "need and url");
        config.version = phoenix_get_string(*mapProject, "version", "0.1.0");
        config.description = phoenix_get_string(*mapProject, "description", "A very important project");
        config.mainBranch = phoenix_get_string(*mapProject, "main_branch", "main");
        config.runnerTag = phoenix_get_string(*mapProject, "runner_tag", "");   //Could be MUST_big_runner
        config.ciToolkitVersion = phoenix_get_string(*mapProject, "ci_toolkit_version", "8.1.4");       //Default version if not specified
        config.ciToolkitUrl = phoenix_get_string(*mapProject, "ci_toolkit_url", "https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS2/citoolkit/phoenixcitoolkitcpp/phoenix-workflow-cpp");
 
        //Authors
        if(mapProject->isKeyExist("authors")){
                const DicoValue * authorDico = mapProject->getMap("authors");
                parseProjectMembers(config.authorMap, authorDico);
        }
        //Dependencies
        if(mapProject->isKeyExist("dependencies")){
                const DicoValue * depDico = mapProject->getMap("dependencies");
                if(depDico != NULL && depDico->hasVec()){
                        const std::vector<DicoValue> & vecDep = depDico->getVecChild();
                        std::vector<PString> depList;
                        for(size_t iDep = 0; iDep < vecDep.size(); iDep++){
                                depList.push_back(vecDep[iDep].getString());
                        }
                        if(!project_generator_split_dependencies(config, depList)){
                                std::cerr << termRed() << "project_generator_loadConfig : cannot parse dependencies in config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                                return false;
                        }
                }
        }
        return true;
}
 


bool generate_empty_config(PPath & outFileName, const PString & name, PString& minVersion, PString& maxVersion){
        PString body;
        body += "# To fill the package info use the description below, then remove the commented lines.\n";
        body += "[[Package]]\n";
        body += "# This is the name of your package (eg on your git repository)\n";
        body += "name = \"" + name + "\"\n";
        body += "# # This is the name of your package for the pixi.toml. You can find the name of the pixi package by searching it on prefix.dev \n";
        body += "pixi_name = \"\"\n";
        body += "# If your package provides a CMake configuration file (find File), this should be the value used in find_package().\n";
        body += "cmake_find = \"\"\n";
        body += "# If your package provides a CMake configuration library, this should be the name of the main library target provided by the package.\n";
        body += "cmake_lib = \"\"\n";
        body += "#This is the URL of your package repository if you want to use the pull_extra_module feature of PhoenixCMake (only for Phoenix packages)\n";
        body += "url = \"\"\n\n";
        return outFileName.saveFileContent(body);
}


bool check_package_file(const PPath & fileName, const PString & name, const PPath & packageDir, PPackageAttribute & pkgAttr){
        bool found = false;
        if(fileName.getExtension() != "toml"){
                return found;
        }
        DicoValue dico;
        PPath tomlFile = packageDir / fileName;
        if(!parser_toml(dico, tomlFile)){
                return found;
        }
        const DicoValue* mapPkg = dico.getMap("Package");
        const std::vector<DicoValue> & vecChild = mapPkg->getVecChild();
        for(size_t iChild = 0; iChild < vecChild.size() && !found; ++iChild){
                const DicoValue & pkgBlock = vecChild[iChild];
                PString tomlName = phoenix_get_string(pkgBlock, "name", "");
                if(tomlName == name){
                        pkgAttr.setUrl(phoenix_get_string(pkgBlock, "url", ""));
                        pkgAttr.setPixiName(phoenix_get_string(pkgBlock, "pixi_name", ""));
                        pkgAttr.setCmakeFind(phoenix_get_string(pkgBlock, "cmake_find", ""));
                        pkgAttr.setCmakeLib(phoenix_get_string(pkgBlock, "cmake_lib", ""));
                        if(pkgAttr.getUrl() != "" || pkgAttr.getPixiName() != "" || pkgAttr.getCmakeFind() != "" || pkgAttr.getCmakeLib() != ""){
                                found = true;
                        }else{
                                std::cerr << termRed() << "check_package_file : incomplete package file '"<<tomlFile<<"'" << termDefault() << std::endl;
                        }
                }
        }
        return found;
}


bool is_package_in_dir(std::vector<PPath> & packageFileNames, const PString & name, const PPath & packageDir, PPackageAttribute & pkgAttr){
        for(size_t iFile = 0; iFile < packageFileNames.size(); ++iFile){
                if(check_package_file(packageFileNames[iFile], name, packageDir, pkgAttr)){
                        std::cout << termGreen() << "Found package '" << name << "' in file '" << packageFileNames[iFile] << "'." << termDefault() << std::endl;
                        return true;
                }
        }
        return false;
}


void is_generate_empty_config_ok(PPath & tomlFile, const PString & name, PPackageAttribute & pkgAttr){
        if(!generate_empty_config(tomlFile, name, pkgAttr.getMinVersion(), pkgAttr.getMaxVersion())){
                std::cerr << termRed() << "project_generator_loadPackageInfo : cannot generate empty config file for package '"<<name<<"'" << termDefault() << std::endl;
        }
        else{
                std::cerr << termYellow() << "Package '" << name << "' does not exist in the configuration. A skeleton file has been created at '" << tomlFile << "'. Please complete it manually." << termDefault() << std::endl;
        }
}


bool project_generator_loadPackageInfo(ProjectConfig & config){
        // 1. Get all files in "share/PhoenixGenerator/Packages"
        PPath packageDir = PPath(SYSTEM_INSTALL_DIR) / PPath("share") / PPath("PhoenixGenerator") / PPath("Packages");
        std::cout << "Loading package info from directory '" << packageDir << "'." << std::endl;
        PVecPath packageFileNames = packageDir.getAllFileInDir();
        size_t packageNotFound = 0;
 
        // 2. Search in toml files in PackageDir for each package, and fill other attributes if found
        for(PackageMap::iterator it = config.mapDependencies.begin(); it != config.mapDependencies.end(); ++it){
                const PString & name = it->first;
                PPackageAttribute & pkgAttr = it->second;
 
                if(!is_package_in_dir(packageFileNames, name, packageDir, pkgAttr)){
                        PPath localPackageDir = PPath::getCurrentDirectory() / PPath("Packages");
                        std::cout << "saving file in local dir: " << localPackageDir << std::endl;
                        PPath tomlFile = localPackageDir / PPath(name + ".toml");
                        if(localPackageDir.isDirectoryExist()){
                                PVecPath localPackageFileNames = localPackageDir.getAllFileInDir();
                                if(!is_package_in_dir(localPackageFileNames, name, localPackageDir, pkgAttr)){
                                        is_generate_empty_config_ok(tomlFile, name, pkgAttr);
                                        packageNotFound++;
                                }
                        }
                        //If the folder does not exists it means that the package we are looking for is unknown, so we create an empty config file inside the new created Packages/ directory
                        else{
                                localPackageDir.createDirectory();
                                is_generate_empty_config_ok(tomlFile, name, pkgAttr);
                                packageNotFound++;
                        }
                }
        }
        if(packageNotFound != 0){
                std::cout << termRed() << packageNotFound << " package(s) not found in the package directory." << termDefault() << std::endl;
        }
        return packageNotFound == 0;
}