Merge pull request #17 from Neko-Box-Coder/CopyFiles

Ability to copy files for dependencies

Author: Neko-Box-Coder

CMakeLists.txt

@@ -85,6 +85,7 @@ add_executable(runcpp2
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/FilesTypesInfo.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/StageInfo.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/ProfilesDefines.cpp"
+                        "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/FilesToCopyInfo.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/ProfileHelper.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/CompilingLinking.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/ConfigParsing.cpp"

DefaultYAMLs/DefaultScriptInfo.yaml

@@ -134,3 +134,20 @@
 #         Linux:
 #             "g++":
 #             -   "sudo apt purge MyLibrary"
+#
+#     # (Optional) Files to be copied for each platform and profile
+#     FilesToCopy:
+#         # Target Platform (Default, Windows, Linux, MacOS, or Unix)
+#         Default:
+#             # Profile name (e.g., "g++", "clang++", "msvc", or "Default" for any profile)
+#             "Default":
+#             # List of files to copy (relative to the dependency folder)
+#             -  "assets/textures/sprite.png"
+#         Windows:
+#             "msvc":
+#             -  "assets/textures/sprite.png"
+#             -  "assets/fonts/windows_specific_font.ttf"
+#         Linux:
+#             "g++":
+#             -  "assets/textures/sprite.png"
+#             -  "assets/shaders/linux_optimized_shader.glsl"

Examples/test.cpp

@@ -41,6 +41,11 @@
             "Default":
             -   "cd build && cmake .. -DssLOG_BUILD_TYPE=SHARED"
             -   "cd build && cmake --build . --config Release -j 16"
+    FilesToCopy:
+        # Target Platform (Default, Windows, Linux, MacOS, or Unix)
+        Default:
+            "Default":
+            -  "./Include/ssLogger/ssLog.hpp"
 */
 
 

Include/runcpp2/Data/DependencyInfo.hpp

@@ -6,7 +6,7 @@
 #include "runcpp2/Data/DependencyLinkProperty.hpp"
 #include "runcpp2/Data/DependencyCommands.hpp"
 #include "runcpp2/Data/ParseCommon.hpp"
-
+#include "runcpp2/Data/FilesToCopyInfo.hpp"
 #include "ryml.hpp"
 
 #include <string>
@@ -29,6 +29,7 @@ namespace runcpp2
                 std::unordered_map<PlatformName, DependencyCommands> Setup;
                 std::unordered_map<PlatformName, DependencyCommands> Cleanup;
                 std::unordered_map<PlatformName, DependencyCommands> Build;
+                std::unordered_map<PlatformName, FilesToCopyInfo> FilesToCopy;
 
                 bool ParseYAML_Node(ryml::ConstNodeRef& node);
                 std::string ToString(std::string indentation) const;

Include/runcpp2/Data/FilesToCopyInfo.hpp

@@ -0,0 +1,24 @@
+#ifndef RUNCPP2_DATA_FILES_TO_COPY_INFO_HPP
+#define RUNCPP2_DATA_FILES_TO_COPY_INFO_HPP
+
+#include "runcpp2/Data/ParseCommon.hpp"
+#include "ryml.hpp"
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace runcpp2
+{
+    namespace Data
+    {
+        struct FilesToCopyInfo
+        {
+            std::unordered_map<ProfileName, std::vector<std::string>> ProfileFiles;
+            
+            bool ParseYAML_Node(const ryml::ConstNodeRef& node);
+            std::string ToString(std::string indentation) const;
+        };
+    }
+}
+
+#endif

Src/runcpp2/Data/DependencyInfo.cpp

@@ -17,7 +17,8 @@ bool runcpp2::Data::DependencyInfo::ParseYAML_Node(ryml::ConstNodeRef& node)
         NodeRequirement("LinkProperties", ryml::NodeType_e::MAP, false, false),
         NodeRequirement("Setup", ryml::NodeType_e::MAP, false, true),
         NodeRequirement("Cleanup", ryml::NodeType_e::MAP, false, true),
-        NodeRequirement("Build", ryml::NodeType_e::MAP, false, true)
+        NodeRequirement("Build", ryml::NodeType_e::MAP, false, true),
+        NodeRequirement("FilesToCopy", ryml::NodeType_e::MAP, false, true)
     };
 
     if(!CheckNodeRequirements(node, requirements))
@@ -141,6 +142,24 @@ bool runcpp2::Data::DependencyInfo::ParseYAML_Node(ryml::ConstNodeRef& node)
         }
     }
 
+    if(ExistAndHasChild(node, "FilesToCopy"))
+    {
+        for(int i = 0; i < node["FilesToCopy"].num_children(); ++i)
+        {
+            FilesToCopyInfo currentFilesToCopy;
+            ryml::ConstNodeRef currentFilesToCopyNode = node["FilesToCopy"][i];
+            PlatformName platform = GetKey(currentFilesToCopyNode);
+            
+            if(!currentFilesToCopy.ParseYAML_Node(currentFilesToCopyNode))
+            {
+                ssLOG_ERROR("DependencyInfo: Failed to parse FilesToCopy");
+                return false;
+            }
+            
+            FilesToCopy[platform] = currentFilesToCopy;
+        }
+    }
+
     return true;
 
     INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
@@ -200,5 +219,12 @@ std::string runcpp2::Data::DependencyInfo::ToString(std::string indentation) con
         out += it->second.ToString(indentation + "            ");
     }
 
+    out += indentation + "    FilesToCopy:\n";
+    for(auto it = FilesToCopy.begin(); it != FilesToCopy.end(); ++it)
+    {
+        out += indentation + "        " + it->first + ":\n";
+        out += it->second.ToString(indentation + "            ");
+    }
+    
     return out;
 }

Src/runcpp2/Data/FilesToCopyInfo.cpp

@@ -0,0 +1,44 @@
+#include "runcpp2/Data/FilesToCopyInfo.hpp"
+#include "runcpp2/ParseUtil.hpp"
+#include "ssLogger/ssLog.hpp"
+
+bool runcpp2::Data::FilesToCopyInfo::ParseYAML_Node(const ryml::ConstNodeRef& node)
+{
+    INTERNAL_RUNCPP2_SAFE_START();
+    
+    if(!node.is_map())
+    {
+        ssLOG_ERROR("FilesToCopyInfo: Node is not a Map");
+        return false;
+    }
+    
+    for(int i = 0; i < node.num_children(); i++)
+    {
+        if(!node[i].is_seq())
+        {
+            ssLOG_ERROR("FilesToCopyInfo: Node is not a sequence");
+            return false;
+        }
+        
+        ProfileName profile = GetKey(node[i]);
+        for(int j = 0; j < node[i].num_children(); j++)
+            ProfileFiles[profile].push_back(GetValue(node[i][j]));
+    }
+    
+    return true;
+    
+    INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
+}
+
+std::string runcpp2::Data::FilesToCopyInfo::ToString(std::string indentation) const
+{
+    std::string out;
+    for(auto it = ProfileFiles.begin(); it != ProfileFiles.end(); it++)
+    {
+        out += indentation + it->first + ":\n";
+        for(int i = 0; i < it->second.size(); i++)
+            out += indentation + "-   " + it->second[i] + "\n";
+    }
+    
+    return out;
+}

Src/runcpp2/DependenciesHelper.cpp

@@ -493,6 +493,66 @@ bool runcpp2::CopyDependenciesBinaries( const ghc::filesystem::path& buildDir,
 
     for(int i = 0; i < availableDependencies.size(); ++i)
     {
+        std::vector<std::string> currentProfileNames;
+        profile.GetNames(currentProfileNames);
+        
+        if(runcpp2::HasValueFromPlatformMap(availableDependencies.at(i)->FilesToCopy))
+        {
+            const runcpp2::Data::FilesToCopyInfo& filesToCopy = 
+                *runcpp2::GetValueFromPlatformMap(availableDependencies.at(i)->FilesToCopy);
+            
+            std::string profileNameToUse;
+            for(int j = 0; j < currentProfileNames.size(); ++j)
+            {
+                if( filesToCopy.ProfileFiles.find(currentProfileNames.at(j)) != 
+                    filesToCopy.ProfileFiles.end())
+                {
+                    profileNameToUse = currentProfileNames.at(j);
+                    break;
+                }
+            }
+            
+            if(!profileNameToUse.empty())
+            {
+                const std::vector<std::string>& filesToCopyForProfile = 
+                    filesToCopy.ProfileFiles.at(profileNameToUse);
+                
+                for(int j = 0; j < filesToCopyForProfile.size(); ++j)
+                {
+                    ghc::filesystem::path srcPath = 
+                        ghc::filesystem::path(dependenciesCopiesPaths.at(i)) / 
+                        filesToCopyForProfile.at(j);
+                    
+                    ghc::filesystem::path destPath = 
+                        buildDir / ghc::filesystem::path(filesToCopyForProfile.at(j)).filename();
+                    
+                    std::error_code e;
+                    //TODO: Maybe we can check if destPath timestamp is newer and avoid copy?
+                    if(ghc::filesystem::exists(srcPath, e))
+                    {
+                        ghc::filesystem::copy(  srcPath, 
+                                                destPath, 
+                                                ghc::filesystem::copy_options::overwrite_existing, 
+                                                e);
+                        
+                        if(e)
+                        {
+                            ssLOG_ERROR("Failed to copy file from " << srcPath.string() << 
+                                        " to " << destPath.string());
+                            ssLOG_ERROR("Error: " << e.message());
+                            return false;
+                        }
+                        
+                        ssLOG_INFO("Copied from " << srcPath.string());
+                        ssLOG_INFO("Copied to " << destPath.string());
+                        outCopiedBinariesPaths.push_back(runcpp2::ProcessPath(destPath));
+                    }
+                    else
+                        ssLOG_WARNING("File not found: " << srcPath.string());
+                }
+            }
+        }
+
         std::vector<std::string> extensionsToCopy;
 
         //Get all the file extensions to copy
@@ -525,9 +585,6 @@ bool runcpp2::CopyDependenciesBinaries( const ghc::filesystem::path& buildDir,
         const PropertyMap& linkProperties = availableDependencies.at(i)->LinkProperties;
 
         //See if we can find the link properties with the profile name
-        std::vector<std::string> currentProfileNames;
-        profile.GetNames(currentProfileNames);
-        
         auto foundPropertyIt = linkProperties.end();
         for(int j = 0; j < currentProfileNames.size(); ++j)
         {

Src/runcpp2/PlatformUtil.cpp

@@ -104,11 +104,10 @@ bool runcpp2::RunCommandAndGetOutput(   const std::string& command,
         sys2Result = 
             System2ReadFromOutput(  &commandInfo, 
                                     const_cast<char*>(outOutput.data()) + outOutput.size() - 4096,
-                                    4096 - 1, 
+                                    4096, 
                                     &byteRead);
 
-        outOutput.resize(outOutput.size() - 4096 + byteRead + 1);
-        outOutput.back() = '\0';
+        outOutput.resize(outOutput.size() + byteRead);
     }
     while(sys2Result == SYSTEM2_RESULT_READ_NOT_FINISHED);
 

Src/runcpp2/runcpp2.cpp

@@ -857,13 +857,15 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                 filesToCopyPaths.push_back(copiedBinariesPaths.at(i));
         }
 
-        ssLOG_DEBUG("Files to link:");
-        for(int i = 0; i < linkFilesPaths.size(); ++i)
-            ssLOG_DEBUG("  " << linkFilesPaths[i]);
+        {
+            ssLOG_DEBUG("Files to link:");
+            for(int i = 0; i < linkFilesPaths.size(); ++i)
+                ssLOG_DEBUG("  " << linkFilesPaths[i]);
 
-        ssLOG_INFO("Files to copy:");
-        for(int i = 0; i < filesToCopyPaths.size(); ++i)
-            ssLOG_INFO("  " << filesToCopyPaths[i]);
+            ssLOG_DEBUG("Files to copy:");
+            for(int i = 0; i < filesToCopyPaths.size(); ++i)
+                ssLOG_DEBUG("  " << filesToCopyPaths[i]);
+        }
 
         // Update finalObjectWriteTime
         for(int i = 0; i < linkFilesPaths.size(); ++i)
@@ -1008,6 +1010,8 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                     ssLOG_ERROR("Failed to copy output file: " << e.message());
                     return PipelineResult::UNEXPECTED_FAILURE;
                 }
+                
+                ssLOG_DEBUG("Copied " << target << " to " << destFile);
             }
 
             // Copy the files that need to be copied
@@ -1024,6 +1028,8 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                                 e.message());
                     return PipelineResult::UNEXPECTED_FAILURE;
                 }
+
+                ssLOG_DEBUG("Copied " << srcFile << " to " << destFile);
             }
 
             ssLOG_BASE("Build completed. Files copied to " << buildOutputDir);