project_generator_load.cpp File Reference

#include "phoenix_color.h"
#include "parser_toml.h"
#include "project_generator_load.h"

Include dependency graph for project_generator_load.cpp:

Go to the source code of this file.

Functions
bool	check_package_file (const PPath &fileName, const PString &name, const PPath &packageDir, PPackageAttribute &pkgAttr)
	Check the package file.
bool	generate_empty_config (PPath &outFileName, const PString &name, PString &minVersion, PString &maxVersion)
	Generate an empty package info file skeleton.
void	is_generate_empty_config_ok (PPath &tomlFile, const PString &name, PPackageAttribute &pkgAttr)
	Generate an empty package info file skeleton and notify the user.
bool	is_package_in_dir (std::vector< PPath > &packageFileNames, const PString &name, const PPath &packageDir, PPackageAttribute &pkgAttr)
	Search the package in the package directory.
bool	parseProjectMembers (ProjectMembersMap &memberMap, const DicoValue *memberDico)
	Parse project members (authors, maintainers, contributors) from TOML data.
bool	project_generator_loadConfig (ProjectConfig &config, const PPath &descriptionFile)
	Load the project configuration.
bool	project_generator_loadPackageInfo (ProjectConfig &config)
	This function should load the package info file from share/PhoenixGenerator/Packages and retrieve the infos in the datastructure.
bool	project_generator_split_dependencies (ProjectConfig &config, std::vector< PString > &vecDependencies)
	Split dependencies strings into name, min_version, max_version and fill the map of dependencies.

Function Documentation

check_package_file()

bool check_package_file	(	const PPath &	fileName,
		const PString &	name,
		const PPath &	packageDir,
		PPackageAttribute &	pkgAttr )

Check the package file.

Parameters

	fileName	: configuration file
	name	: name of the project to search
	packageDir	: directory where package configuration are stored
[out]	pkgAttr	: PPackageAttribute to be set

Returns

true if the package name has been found, false otherwise

Definition at line 179 of file project_generator_load.cpp.

                                                                                                                            {
        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;
}

References PPackageAttribute::getCmakeFind(), PPackageAttribute::getCmakeLib(), PPackageAttribute::getPixiName(), PPackageAttribute::getUrl(), PPackageAttribute::setCmakeFind(), PPackageAttribute::setCmakeLib(), PPackageAttribute::setPixiName(), and PPackageAttribute::setUrl().

Referenced by is_package_in_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_empty_config()

bool generate_empty_config	(	PPath &	outFileName,
		const PString &	name,
		PString &	minVersion,
		PString &	maxVersion )

Generate an empty package info file skeleton.

Parameters

[out]	outFileName	: output file name
	name	: name of the package
	minVersion	: minimum version of the package
	maxVersion	: maximum version of the package

Definition at line 155 of file project_generator_load.cpp.

                                                                                                               {
        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);
}

Referenced by is_generate_empty_config_ok().

Here is the caller graph for this function:

is_generate_empty_config_ok()

void is_generate_empty_config_ok	(	PPath &	tomlFile,
		const PString &	name,
		PPackageAttribute &	pkgAttr )

Generate an empty package info file skeleton and notify the user.

Parameters

[out]	tomlFile	: output file name
	name	: name of the package
	pkgAttr	: PPackageAttribute containing version info

Definition at line 231 of file project_generator_load.cpp.

                                                                                                     {
        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;
        }
}

References generate_empty_config(), PPackageAttribute::getMaxVersion(), and PPackageAttribute::getMinVersion().

Referenced by project_generator_loadPackageInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

is_package_in_dir()

bool is_package_in_dir	(	std::vector< PPath > &	packageFileNames,
		const PString &	name,
		const PPath &	packageDir,
		PPackageAttribute &	pkgAttr )

Search the package in the package directory.

Parameters

	packageFileNames	: list of package configuration files
	name	: name of the project to search
	packageDir	: directory where package configuration are stored
[out]	pkgAttr	: PPackageAttribute to be set

Returns

true if the package name has been found, false otherwise

Definition at line 216 of file project_generator_load.cpp.

                                                                                                                                        {
        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;
}

References check_package_file().

Referenced by project_generator_loadPackageInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

parseProjectMembers()

bool parseProjectMembers	(	ProjectMembersMap &	memberMap,
		const DicoValue *	memberDico )

Parse project members (authors, maintainers, contributors) from TOML data.

Parameters

[out]	memberMap	: map to fill with parsed members
	memberDico	: TOML dictionary containing the members data

Returns

true on success, false otherwise

Definition at line 57 of file project_generator_load.cpp.

                                                                                     {
        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;
}

References PProjectMembers::getFirstName(), PProjectMembers::getLastName(), PProjectMembers::setAffiliation(), PProjectMembers::setEmail(), PProjectMembers::setFirstName(), and PProjectMembers::setLastName().

Referenced by project_generator_loadConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

project_generator_loadConfig()

bool project_generator_loadConfig	(	ProjectConfig &	config,
		const PPath &	descriptionFile )

Load the project configuration.

Parameters

[out]	config	: loaded project configuration
	descriptionFile	: description of the full project

Returns

true on success, false otherwise

Definition at line 84 of file project_generator_load.cpp.

                                                                                        {
        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;
        }
        //TODO : It should be better to tell if there are missing values, but it's late ...
        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", "3.0.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");
 
        //Keywords
        if(mapProject->isKeyExist("keywords")){
                const DicoValue * keywordDico = mapProject->getMap("keywords");
                if(keywordDico != NULL && keywordDico->hasVec()){
                        const std::vector<DicoValue> & vecKeyword = keywordDico->getVecChild();
                        for(size_t iKeyword = 0; iKeyword < vecKeyword.size(); iKeyword++){
                                config.keywordList.push_back(vecKeyword[iKeyword].getString());;
                        }
                }
        }
        //Authors
        if(mapProject->isKeyExist("authors")){
                const DicoValue * authorDico = mapProject->getMap("authors");
                parseProjectMembers(config.authorMap, authorDico);
        }
        //Maintainers
        if(mapProject->isKeyExist("maintainers")){
                const DicoValue * maintainerDico = mapProject->getMap("maintainers");
                parseProjectMembers(config.maintainerMap, maintainerDico);
        }
        //Contributors
        if(mapProject->isKeyExist("contributors")){
                const DicoValue * contributorDico = mapProject->getMap("contributors");
                parseProjectMembers(config.contributorMap, contributorDico);
        }
        //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;
}

References ProjectConfig::authorMap, ProjectConfig::ciToolkitUrl, ProjectConfig::ciToolkitVersion, ProjectConfig::contributorMap, ProjectConfig::description, ProjectConfig::keywordList, ProjectConfig::mainBranch, ProjectConfig::maintainerMap, ProjectConfig::name, parseProjectMembers(), project_generator_split_dependencies(), ProjectConfig::runnerTag, ProjectConfig::url, and ProjectConfig::version.

Referenced by simple_project_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_generator_loadPackageInfo()

bool project_generator_loadPackageInfo

(

ProjectConfig &

config

)

This function should load the package info file from share/PhoenixGenerator/Packages and retrieve the infos in the datastructure.

Parameters

[out]

config

: project configuration to fill

Returns

true on success, false otherwise

Definition at line 244 of file project_generator_load.cpp.

                                                              {
        // 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;
}

References is_generate_empty_config_ok(), is_package_in_dir(), and ProjectConfig::mapDependencies.

Referenced by simple_project_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_generator_split_dependencies()

bool project_generator_split_dependencies	(	ProjectConfig &	config,
		std::vector< PString > &	vecDependencies )

Split dependencies strings into name, min_version, max_version and fill the map of dependencies.

Parameters

[out]	config	: project configuration to fill
	vecDependencies	: list of dependencies strings

Returns

true on success, false otherwise

Definition at line 16 of file project_generator_load.cpp.

                                                                                                       {
        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;
}

References ProjectConfig::mapDependencies.

Referenced by project_generator_loadConfig().

Here is the caller graph for this function: