Merge pull request #14 from Neko-Box-Coder/BuildOption

Neko-Box-Coder · web-flow · commit 9e978cf540db · 2024-09-28T22:36:51.000+01:00
Adding build option
diff --git a/Include/runcpp2/runcpp2.hpp b/Include/runcpp2/runcpp2.hpp
@@ -21,6 +21,7 @@ namespace runcpp2
         SHOW_USER_CONFIG,
         SCRIPT_TEMPLATE,
         WATCH,
+        BUILD,
         COUNT
     };
     
@@ -60,6 +61,7 @@ namespace runcpp2
                                     const std::vector<std::string>& runArgs,
                                     const Data::ScriptInfo* lastScriptInfo,
                                     Data::ScriptInfo& outScriptInfo,
+                                    const std::string& buildOutputDir,
                                     int& returnStatus);
 }
 
diff --git a/README.md b/README.md
@@ -86,12 +86,12 @@ or `Header`
 - `Setup`, `Build` and `Cleanup`: List of shell commands for one time setup, building and 
 cleaning up
 
-To access the source files of the dependencies, you can specify runcpp2 to build locally at 
-where it script is by passing the `--local` flag. This is useful when you want to
+To access the source files of the dependencies, you can specify runcpp2 to build locally in 
+the current working directory by passing the `--local` flag. This is useful when you want to
 look at the headers of the dependencies.
 
 ```shell
 runcpp2 --local ./script.cpp
 ```
 
-This will create a `.runcpp2` folder and all the builds and dependencies will be inside it.
+This will create a `.runcpp2` folder in the current working directory, and all the builds and dependencies will be inside it.
diff --git a/Src/runcpp2/DependenciesHelper.cpp b/Src/runcpp2/DependenciesHelper.cpp
@@ -616,6 +616,7 @@ bool runcpp2::CopyDependenciesBinaries( const ghc::filesystem::path& buildDir,
                     if(!extensionMatched)
                         continue;
                     
+                    //TODO: Group object files in folders to avoid name collision
                     ghc::filesystem::path copiedPath = buildDir / it.path().filename();
                     
                     //Check if we have previously copied the dependencies to the folder
diff --git a/Src/runcpp2/main.cpp b/Src/runcpp2/main.cpp
@@ -174,7 +174,7 @@ int main(int argc, char* argv[])
     std::unordered_map<runcpp2::CmdOptions, std::string> currentOptions;
 
     {
-        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 10, "Update this");
+        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 11, "Update this");
         std::unordered_map<std::string, runcpp2::OptionInfo> longOptionsMap =
         {
             {
@@ -212,10 +212,14 @@ int main(int argc, char* argv[])
             {
                 "--watch",
                 runcpp2::OptionInfo(runcpp2::CmdOptions::WATCH, false)
+            },
+            {
+                "--build",
+                runcpp2::OptionInfo(runcpp2::CmdOptions::BUILD, false)
             }
         };
         
-        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 10, "Update this");
+        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 11, "Update this");
         std::unordered_map<std::string, const runcpp2::OptionInfo&> shortOptionsMap = 
         {
             {"-r", longOptionsMap.at("--reset-cache")},
@@ -226,7 +230,8 @@ int main(int argc, char* argv[])
             {"-l", longOptionsMap.at("--local")},
             {"-s", longOptionsMap.at("--show-config-path")},
             {"-t", longOptionsMap.at("--create-script-template")},
-            {"-w", longOptionsMap.at("--watch")}
+            {"-w", longOptionsMap.at("--watch")},
+            {"-b", longOptionsMap.at("--build")}
         };
         
         currentArgIndex = ParseArgs(longOptionsMap, shortOptionsMap, currentOptions, argc, argv);
@@ -243,18 +248,19 @@ int main(int argc, char* argv[])
     //Help message
     if(currentOptions.count(runcpp2::CmdOptions::HELP))
     {
-        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 10, "Update this");
+        static_assert(static_cast<int>(runcpp2::CmdOptions::COUNT) == 11, "Update this");
         ssLOG_BASE("Usage: runcpp2 [options] [input_file]");
         ssLOG_BASE("Options:");
         ssLOG_BASE("    -r, --[r]eset-cache                     Deletes all cache and build everything from scratch");
         ssLOG_BASE("    -c, --reset-user-[c]onfig               Replace current user config with the default one");
         ssLOG_BASE("    -e, --[e]xecutable                      Runs as executable instead of shared library");
         ssLOG_BASE("    -h, --[h]elp                            Show this help message");
         ssLOG_BASE("    -d, --remove-[d]ependencies             Remove dependencies listed in the script");
-        ssLOG_BASE("    -l, --[l]ocal                           Build the script and dependencies locally");
+        ssLOG_BASE("    -l, --[l]ocal                           Build in the current working directory under .runcpp2 directory");
         ssLOG_BASE("    -s, --[s]how-config-path                Show where runcpp2 is reading the config from");
         ssLOG_BASE("    -t, --create-script-[t]emplate <file>   Creates/prepend runcpp2 script info template");
         ssLOG_BASE("    -w, --[w]atch                           Watch script changes and output any compiling errors");
+        ssLOG_BASE("    -b, --[b]uild                           Build the script and copy output files to the working directory");
         
         return 0;
     }
@@ -321,6 +327,13 @@ int main(int argc, char* argv[])
         }
     }
     
+    if( currentOptions.count(runcpp2::CmdOptions::BUILD) > 0 &&
+        currentOptions.count(runcpp2::CmdOptions::WATCH) > 0)
+    {
+        ssLOG_ERROR("--build option is not compatible with --watch option");
+        return -1;
+    }
+    
     runcpp2::Data::ScriptInfo parsedScriptInfo;
     
     if(currentOptions.count(runcpp2::CmdOptions::WATCH))
@@ -341,8 +354,6 @@ int main(int argc, char* argv[])
             {
                 int result = 0;
     
-                
-    
                 runcpp2::PipelineResult pipelineResult = 
                     runcpp2::StartPipeline( script, 
                                             profiles, 
@@ -351,6 +362,7 @@ int main(int argc, char* argv[])
                                             scriptArgs,
                                             lastParsedScriptInfo,
                                             parsedScriptInfo,
+                                            "",
                                             result);
             
                 static_assert(static_cast<int>(runcpp2::PipelineResult::COUNT) == 12, "Update this");
@@ -384,13 +396,18 @@ int main(int argc, char* argv[])
     
     int result = 0;
     
+    std::string outputDir;
+    if(currentOptions.count(runcpp2::CmdOptions::BUILD) > 0)
+        outputDir = ghc::filesystem::path(script).parent_path().string();
+    
     if(runcpp2::StartPipeline(  script, 
                                 profiles, 
                                 preferredProfile, 
                                 currentOptions, 
                                 scriptArgs,
                                 nullptr,
                                 parsedScriptInfo,
+                                outputDir,
                                 result) != runcpp2::PipelineResult::SUCCESS)
     {
         return -1;
diff --git a/Src/runcpp2/runcpp2.cpp b/Src/runcpp2/runcpp2.cpp
@@ -23,17 +23,18 @@ namespace
     bool CreateLocalBuildDirectory( const std::string& scriptPath, 
                                     ghc::filesystem::path& outBuildPath)
     {
-        std::string scriptDirectory = ghc::filesystem::path(scriptPath).parent_path().string();
+        // Get the current working directory
+        std::string currentWorkingDir = ghc::filesystem::current_path().string();
         
-        //Create the runcpp2 directory
-        std::string runcpp2Dir = scriptDirectory + "/.runcpp2";
+        // Create the .runcpp2 directory in the current working directory
+        std::string runcpp2Dir = currentWorkingDir + "/.runcpp2";
         
         std::error_code e;
         if(!ghc::filesystem::exists(runcpp2Dir, e))
         {
             if(!ghc::filesystem::create_directory(runcpp2Dir, e))
             {
-                ssLOG_ERROR("Failed to create runcpp2 directory");
+                ssLOG_ERROR("Failed to create .runcpp2 directory in the current working directory");
                 return false;
             }
         }
@@ -481,6 +482,7 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                         const std::vector<std::string>& runArgs,
                         const Data::ScriptInfo* lastScriptInfo,
                         Data::ScriptInfo& outScriptInfo,
+                        const std::string& buildOutputDir,
                         int& returnStatus)
 {
     INTERNAL_RUNCPP2_SAFE_START();
@@ -559,6 +561,7 @@ runcpp2::StartPipeline( const std::string& scriptPath,
     #endif
 
     //Parsing the script, setting up dependencies, compiling and linking
+    std::vector<std::string> filesToCopyPaths;
     {
         //Check if there's script info as yaml file instead
         std::error_code e;
@@ -611,9 +614,8 @@ runcpp2::StartPipeline( const std::string& scriptPath,
         
         //Create build directory
         {
-            const bool localBuildDir = currentOptions.count(CmdOptions::LOCAL) > 0;
             bool createdBuildDir = false;
-            if(localBuildDir)
+            if(currentOptions.count(CmdOptions::LOCAL) > 0)
             {
                 if(CreateLocalBuildDirectory(absoluteScriptPath, buildDir))
                     createdBuildDir = true;
@@ -796,18 +798,70 @@ runcpp2::StartPipeline( const std::string& scriptPath,
             return PipelineResult::UNEXPECTED_FAILURE;
         }
         
-        //Update finalObjectWriteTime
+        std::vector<std::string> linkFilesPaths;
+        std::unordered_set<std::string> linkExtensions;
+        const Data::FilesTypesInfo& currentFileTypes = profiles.at(profileIndex).FilesTypes;
+
+        //Populate the set of link extensions
+        if(runcpp2::HasValueFromPlatformMap(currentFileTypes.StaticLinkFile.Extension))
+        {
+            linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(currentFileTypes.StaticLinkFile
+                                                                                    .Extension));
+        }
+        if(runcpp2::HasValueFromPlatformMap(currentFileTypes.SharedLinkFile.Extension))
+        {
+            linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(currentFileTypes.SharedLinkFile
+                                                                                    .Extension));
+        }
+        if(runcpp2::HasValueFromPlatformMap(currentFileTypes.ObjectLinkFile.Extension))
+        {
+            linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(currentFileTypes.ObjectLinkFile
+                                                                                    .Extension));
+        }
+
+        //Separate the copied files from dependencies into files to link and files to copy
         for(int i = 0; i < copiedBinariesPaths.size(); ++i)
         {
-            if(!ghc::filesystem::exists(copiedBinariesPaths.at(i), e))
+            ghc::filesystem::path filePath(copiedBinariesPaths.at(i));
+            std::string extension = filePath.extension().string();
+
+            //Check if the file is a link file based on its extension
+            if(linkExtensions.find(extension) != linkExtensions.end())
             {
-                ssLOG_ERROR(copiedBinariesPaths.at(i) << " reported as cached but doesn't exist");
+                linkFilesPaths.push_back(copiedBinariesPaths.at(i));
+                
+                //Special case when SharedLinkFile and SharedLibraryFile share the same extension
+                if( runcpp2::HasValueFromPlatformMap(currentFileTypes.SharedLibraryFile.Extension) && 
+                    *runcpp2::GetValueFromPlatformMap(currentFileTypes  .SharedLibraryFile
+                                                                        .Extension) == extension)
+                {
+                    filesToCopyPaths.push_back(copiedBinariesPaths.at(i));
+                }
+            }
+            else
+                filesToCopyPaths.push_back(copiedBinariesPaths.at(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]);
+        
+        // Update finalObjectWriteTime
+        for(int i = 0; i < linkFilesPaths.size(); ++i)
+        {
+            if(!ghc::filesystem::exists(linkFilesPaths.at(i), e))
+            {
+                ssLOG_ERROR(linkFilesPaths.at(i) << " reported as cached but doesn't exist");
                 return PipelineResult::UNEXPECTED_FAILURE;
             }
             
             ghc::filesystem::file_time_type lastWriteTime = 
-                ghc::filesystem::last_write_time(copiedBinariesPaths.at(i), e);
-        
+                ghc::filesystem::last_write_time(linkFilesPaths.at(i), e);
+
             if(lastWriteTime > finalObjectWriteTime)
                 finalObjectWriteTime = lastWriteTime;
         }
@@ -819,11 +873,11 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                             currentOptions.count(CmdOptions::EXECUTABLE) > 0,
                             scriptName,
                             exeExt,
-                            copiedBinariesPaths,
+                            linkFilesPaths,
                             finalObjectWriteTime))
         {
             for(int i = 0; i < cachedObjectsFiles.size(); ++i)
-                copiedBinariesPaths.push_back(cachedObjectsFiles.at(i));
+                linkFilesPaths.push_back(cachedObjectsFiles.at(i));
             
             if(currentOptions.count(CmdOptions::WATCH) > 0)
             {
@@ -845,7 +899,7 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                                             scriptInfo,
                                             availableDependencies,
                                             profiles.at(profileIndex),
-                                            copiedBinariesPaths,
+                                            linkFilesPaths,
                                             currentOptions.count(CmdOptions::EXECUTABLE) > 0,
                                             exeExt))
             {
@@ -896,26 +950,66 @@ runcpp2::StartPipeline( const std::string& scriptPath,
             return PipelineResult::COMPILE_LINK_FAILED;
         }
         
-        if(currentOptions.count(CmdOptions::EXECUTABLE) > 0)
+        if(currentOptions.count(CmdOptions::BUILD) == 0)
         {
-            //Running the script
-            if(!RunCompiledScript(target, absoluteScriptPath, runArgs, returnStatus))
+            if(currentOptions.count(CmdOptions::EXECUTABLE) > 0)
+            {
+                //Running the script
+                if(!RunCompiledScript(target, absoluteScriptPath, runArgs, returnStatus))
+                {
+                    ssLOG_ERROR("Failed to run script");
+                    return PipelineResult::RUN_SCRIPT_FAILED;
+                }
+                
+                return PipelineResult::SUCCESS;
+            }
+            //Load the shared library and run it
+            else
             {
-                ssLOG_ERROR("Failed to run script");
-                return PipelineResult::RUN_SCRIPT_FAILED;
+                if(!RunCompiledSharedLib(absoluteScriptPath, target, runArgs, returnStatus))
+                {
+                    ssLOG_ERROR("Failed to run script");
+                    return PipelineResult::RUN_SCRIPT_FAILED;
+                }
+                
+                return PipelineResult::SUCCESS;
             }
-            
-            return PipelineResult::SUCCESS;
         }
-        //Load the shared library and run it
         else
         {
-            if(!RunCompiledSharedLib(absoluteScriptPath, target, runArgs, returnStatus))
+            std::error_code e;
+            
+            // Copy the output file
             {
-                ssLOG_ERROR("Failed to run script");
-                return PipelineResult::RUN_SCRIPT_FAILED;
+                ghc::filesystem::path destFile = 
+                    ghc::filesystem::path(buildOutputDir) / target.filename();
+                
+                ghc::filesystem::copy(  target, destFile, 
+                                        ghc::filesystem::copy_options::overwrite_existing, e);
+                if(e)
+                {
+                    ssLOG_ERROR("Failed to copy output file: " << e.message());
+                    return PipelineResult::UNEXPECTED_FAILURE;
+                }
             }
-            
+
+            // Copy the files that need to be copied
+            for(int i = 0; i < filesToCopyPaths.size(); ++i)
+            {
+                ghc::filesystem::path srcFile(filesToCopyPaths.at(i));
+                ghc::filesystem::path destFile = 
+                    ghc::filesystem::path(buildOutputDir) / srcFile.filename();
+                ghc::filesystem::copy(  srcFile, destFile, 
+                                        ghc::filesystem::copy_options::overwrite_existing, e);
+                if(e)
+                {
+                    ssLOG_ERROR("Failed to copy file " << filesToCopyPaths.at(i) << ": " << 
+                                e.message());
+                    return PipelineResult::UNEXPECTED_FAILURE;
+                }
+            }
+
+            ssLOG_INFO("Build completed. Files copied to " << buildOutputDir);
             return PipelineResult::SUCCESS;
         }
     }
diff --git a/TODO.md b/TODO.md
@@ -1,6 +1,6 @@
 TODO:
 - Group object files in folders to avoid name collision
-- Option for build only
+- Allow to specify files to copy for dependencies
 - Allow runcpp2 to be library
 - Add ability to add defines for cross-compiler
 - Ability to compile runcpp2 as single cpp
