Refactoring to return list of names for a profile

Author: Neko-Box-Coder

Include/runcpp2/CompilingLinking.hpp

@@ -9,10 +9,11 @@ namespace runcpp2
 {
     bool CompileAndLinkScript(  const std::string& scriptPath, 
                                 const Data::ScriptInfo& scriptInfo,
+                                const std::vector<Data::DependencyInfo*>& availableDependencies,
                                 const Data::Profile& profile,
                                 const std::vector<std::string>& copiedDependenciesBinariesPaths,
                                 bool buildExecutable,
                                 const std::string exeExt);
 }
 
-#endif
+#endif

Include/runcpp2/Data/Profile.hpp

@@ -23,9 +23,6 @@ namespace runcpp2
             public:
                 std::string Name;
 
-                //TODO: Add a function for getting value from map that uses profile name as key
-                //      Or maybe just a function that return all the names
-                
                 std::unordered_set<std::string> NameAliases;
                 std::unordered_set<std::string> FileExtensions;
                 std::unordered_set<std::string> Languages;
@@ -36,6 +33,7 @@ namespace runcpp2
                 StageInfo Compiler;
                 StageInfo Linker;
 
+                void GetNames(std::vector<std::string>& outNames) const;
                 bool ParseYAML_Node(ryml::ConstNodeRef& profileNode);
                 std::string ToString(std::string indentation) const;
         };

Src/runcpp2/CompilingLinking.cpp

@@ -31,18 +31,15 @@ namespace
             *runcpp2::GetValueFromPlatformMap(overrideFlags);
 
         std::string foundProfileName;
+        std::vector<std::string> currentProfileNames;
+        profile.GetNames(currentProfileNames);
 
-        if(currentFlagsOverride.FlagsOverrides.count(profile.Name) > 0)
-            foundProfileName = profile.Name;
-        else
+        for(int i = 0; i < currentProfileNames.size(); ++i)
         {
-            for(auto it = profile.NameAliases.begin(); it != profile.NameAliases.end(); ++it)
+            if(currentFlagsOverride.FlagsOverrides.count(currentProfileNames.at(i)) > 0)
             {
-                if(currentFlagsOverride.FlagsOverrides.count(*it) > 0)
-                {
-                    foundProfileName = *it;
-                    break;
-                }
+                foundProfileName = currentProfileNames.at(i);
+                break;
             }
         }
 
@@ -83,6 +80,7 @@ namespace
 
     bool CompileScript( const std::string& scriptPath, 
                         const runcpp2::Data::ScriptInfo& scriptInfo,
+                        const std::vector<runcpp2::Data::DependencyInfo*>& availableDependencies,
                         const runcpp2::Data::Profile& profile,
                         bool compileAsExecutable,
                         std::string& outScriptObjectFilePath)
@@ -112,15 +110,13 @@ namespace
 
         //Include Directories
         {
-            for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)
+            //TODO(NOW): Use filtered dependencies instead
+            for(int i = 0; i < availableDependencies.size(); ++i)
             {
-                if(!runcpp2::IsDependencyAvailableForThisPlatform(scriptInfo.Dependencies.at(i)))
-                    continue;
-            
-                for(int j = 0; j < scriptInfo.Dependencies.at(i).AbsoluteIncludePaths.size(); ++j)
+                for(int j = 0; j < availableDependencies.at(i)->AbsoluteIncludePaths.size(); ++j)
                 {
                     const std::string& currentIncludePath = 
-                        scriptInfo.Dependencies.at(i).AbsoluteIncludePaths.at(j);
+                        availableDependencies.at(i)->AbsoluteIncludePaths.at(j);
 
                     substitutionMap["{IncludeDirectoryPath}"].push_back(currentIncludePath);
                 }
@@ -262,6 +258,7 @@ namespace
 
     bool LinkScript(const std::string& scriptPath, 
                     const runcpp2::Data::ScriptInfo& scriptInfo,
+                    const std::vector<runcpp2::Data::DependencyInfo*>& availableDependencies,
                     const runcpp2::Data::Profile& profile,
                     const std::string& scriptObjectFilePath,
                     const std::vector<std::string>& copiedDependenciesBinariesPaths,
@@ -288,46 +285,27 @@ namespace
             AppendAndRemoveFlags(profile, scriptInfo.OverrideLinkFlags, linkFlags);
 
             //Add link flags for the dependencies
-            for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)
+            //TODO(NOW): Use the filtered dependencies
+            for(int i = 0; i < availableDependencies.size(); ++i)
             {
-                if(!runcpp2::IsDependencyAvailableForThisPlatform(scriptInfo.Dependencies.at(i)))
-                    continue;
-                
                 std::string targetProfileName;
+                std::vector<std::string> currentProfileNames;
+                profile.GetNames(currentProfileNames);
 
-                //Check for profile name first
-                if( scriptInfo.Dependencies.at(i).LinkProperties.find(profile.Name) != 
-                    scriptInfo.Dependencies.at(i).LinkProperties.end())
+                for(int j = 0; j < currentProfileNames.size(); ++j)
                 {
-                    targetProfileName = profile.Name;
-                }
-                else
-                {
-                    //If not check for profile name aliases
-                    for(const auto& alias : profile.NameAliases)
-                    {
-                        if( scriptInfo.Dependencies.at(i).LinkProperties.find(alias) != 
-                            scriptInfo.Dependencies.at(i).LinkProperties.end())
-                        {
-                            targetProfileName = alias;
-                            break;
-                        }
-                    }
-                    
-                    //Final check for "All"
-                    if( targetProfileName.empty() &&  
-                        scriptInfo.Dependencies.at(i).LinkProperties.find("All") != 
-                        scriptInfo.Dependencies.at(i).LinkProperties.end())
+                    if( availableDependencies.at(i)->LinkProperties.find(currentProfileNames.at(j)) != 
+                        availableDependencies.at(i)->LinkProperties.end())
                     {
-                        targetProfileName = "All";
+                        targetProfileName = currentProfileNames.at(j);
                     }
                 }
 
                 if(targetProfileName.empty())
                     continue;
 
                 const runcpp2::Data::DependencyLinkProperty& currentLinkProperty = 
-                    scriptInfo.Dependencies.at(i).LinkProperties.at(targetProfileName);
+                    availableDependencies.at(i)->LinkProperties.at(targetProfileName);
 
                 if(runcpp2::HasValueFromPlatformMap(currentLinkProperty.AdditionalLinkOptions))
                 {
@@ -648,6 +626,7 @@ namespace
 
 bool runcpp2::CompileAndLinkScript( const std::string& scriptPath, 
                                     const Data::ScriptInfo& scriptInfo,
+                                    const std::vector<Data::DependencyInfo*>& availableDependencies,
                                     const Data::Profile& profile,
                                     const std::vector<std::string>& copiedDependenciesBinariesPaths,
                                     bool buildExecutable,
@@ -661,14 +640,20 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
 
     std::string scriptObjectFilePath;
 
-    if(!CompileScript(scriptPath, scriptInfo, profile, buildExecutable, scriptObjectFilePath))
+    if(!CompileScript(  scriptPath, 
+                        scriptInfo, 
+                        availableDependencies, 
+                        profile, 
+                        buildExecutable, 
+                        scriptObjectFilePath))
     {
         ssLOG_ERROR("CompileScript failed");
         return false;
     }
 
     if(!LinkScript( scriptPath, 
                     scriptInfo,
+                    availableDependencies,
                     profile,
                     scriptObjectFilePath,
                     copiedDependenciesBinariesPaths,

Src/runcpp2/Data/Profile.cpp

@@ -3,6 +3,17 @@
 #include "runcpp2/ParseUtil.hpp"
 #include "ssLogger/ssLog.hpp"
 
+void runcpp2::Data::Profile::GetNames(std::vector<std::string>& outNames) const
+{
+    outNames.clear();
+    outNames.push_back(Name);
+    for(const auto& alias : NameAliases)
+        outNames.push_back(alias);
+    
+    //Special name all that applies to all profile
+    outNames.push_back("All");
+}
+
 bool runcpp2::Data::Profile::ParseYAML_Node(ryml::ConstNodeRef& profileNode)
 {
     ssLOG_FUNC_DEBUG();

Src/runcpp2/DependenciesHelper.cpp

@@ -133,33 +133,25 @@ namespace
             *runcpp2::GetValueFromPlatformMap(steps);
 
         std::string profileNameToUse;
-        //Check profile name is available first
-        if(dependencySteps.CommandSteps.count(profile.Name) > 0)
-            profileNameToUse = profile.Name;
-        else
+        std::vector<std::string> currentProfileNames;
+        profile.GetNames(currentProfileNames);
+        
+        for(int i = 0; i < currentProfileNames.size(); ++i)
         {
-            //If not check for name alias
-            for(const auto& alias : profile.NameAliases)
-            {
-                if(dependencySteps.CommandSteps.count(alias) > 0)
-                {
-                    profileNameToUse = alias;
-                    break;
-                }
-            }
-            
-            //Otherwise check for "All"
-            if(dependencySteps.CommandSteps.count("All") > 0)
-                profileNameToUse = "All";
-            
-            if(profileNameToUse.empty())
+            if(dependencySteps.CommandSteps.count(currentProfileNames.at(i)) > 0)
             {
-                ssLOG_ERROR("Failed to find steps for profile " << profile.Name << 
-                            " for current platform");
-                return false;
+                profileNameToUse = currentProfileNames.at(i);
+                break;
             }
         }
 
+        if(profileNameToUse.empty())
+        {
+            ssLOG_ERROR("Failed to find steps for profile " << profile.Name << 
+                        " for current platform");
+            return false;
+        }
+        
         //Run the commands
         const std::vector<std::string>& commands = 
             dependencySteps.CommandSteps.at(profileNameToUse);
@@ -551,21 +543,17 @@ bool runcpp2::CopyDependenciesBinaries( const std::string& scriptPath,
             availableDependencies.at(i)->LinkProperties;
 
         //See if we can find the link properties with the profile name
-        auto foundPropertyIt = linkProperties.find(profile.Name);
-        if(foundPropertyIt == linkProperties.end())
+        std::vector<std::string> currentProfileNames;
+        profile.GetNames(currentProfileNames);
+        
+        auto foundPropertyIt = linkProperties.end();
+        for(int j = 0; j < currentProfileNames.size(); ++j)
         {
-            //If not, try alias
-            for(const auto& alias : profile.NameAliases)
-            {
-                foundPropertyIt = linkProperties.find(alias);
-                if(foundPropertyIt != linkProperties.end())
-                    break;
-            }
-            
-            //If not, try All
-            if(foundPropertyIt == linkProperties.end())
-                foundPropertyIt = linkProperties.find("All");
+            foundPropertyIt = linkProperties.find(currentProfileNames.at(j));
+            if(foundPropertyIt != linkProperties.end())
+                break;
         }
+        
         if(foundPropertyIt == linkProperties.end())
         {
             ssLOG_ERROR("Search properties for dependency " << availableDependencies.at(i)->Name <<

Src/runcpp2/ProfileHelper.cpp

@@ -74,12 +74,7 @@ namespace
         if(!scriptExtension.empty())
             scriptExtension.erase(0, 1);
 
-        if(profile.FileExtensions.find(scriptExtension) == profile.FileExtensions.end())
-        {
-            ssLOG_DEBUG("Failed to match file extension for " << scriptExtension);
-            return false;
-        }
-        
+        //If the language is explicitly stated, use it instead of file extension
         if(!scriptInfo.Language.empty())
         {
             if(profile.Languages.find(scriptInfo.Language) == profile.Languages.end())
@@ -88,6 +83,11 @@ namespace
                 return false;
             }
         }
+        else if(profile.FileExtensions.find(scriptExtension) == profile.FileExtensions.end())
+        {
+            ssLOG_DEBUG("Failed to match file extension for " << scriptExtension);
+            return false;
+        }
 
         if(!scriptInfo.RequiredProfiles.empty())
         {

Src/runcpp2/runcpp2.cpp

@@ -450,8 +450,8 @@ int runcpp2::RunScript( const std::string& scriptPath,
         std::vector<std::string> copiedBinariesPaths;
 
         //Process Dependencies
+        std::vector<Data::DependencyInfo*> availableDependencies;
         {
-            std::vector<Data::DependencyInfo*> availableDependencies;
             for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)
             {
                 if(IsDependencyAvailableForThisPlatform(scriptInfo.Dependencies.at(i)))
@@ -469,7 +469,6 @@ int runcpp2::RunScript( const std::string& scriptPath,
                 return -1;
             }
 
-            //If we are resetting cache, we need to clean up the dependencies first
             if( currentOptions.count(CmdOptions::RESET_CACHE) > 0 ||
                 currentOptions.count(CmdOptions::REMOVE_DEPENDENCIES) > 0)
             {
@@ -531,6 +530,7 @@ int runcpp2::RunScript( const std::string& scriptPath,
         {
             if(!CompileAndLinkScript(   absoluteScriptPath, 
                                         scriptInfo,
+                                        availableDependencies,
                                         profiles.at(profileIndex),
                                         copiedBinariesPaths,
                                         (currentOptions.count(CmdOptions::EXECUTABLE) > 0),