Fixing watch mode not working on other source files

Author: Neko-Box-Coder

Include/runcpp2/runcpp2.hpp

@@ -25,6 +25,12 @@ namespace runcpp2
 
     void SetLogLevel(const std::string& logLevel);
 
+    PipelineResult GetLatestSourceWriteTime(const std::string& scriptPath,
+                                            const std::vector<Data::Profile>& profiles,
+                                            const std::string& configPreferredProfile,
+                                            const Data::ScriptInfo& scriptInfo,
+                                            int64_t& outWriteTime);
+
     PipelineResult StartPipeline(   const std::string& scriptPath, 
                                     const std::vector<Data::Profile>& profiles,
                                     const std::string& configPreferredProfile,

Src/runcpp2/PipelineSteps.cpp

@@ -604,8 +604,8 @@ runcpp2::CheckScriptInfoChanges(const ghc::filesystem::path& buildDir,
     }
 
     std::vector<ghc::filesystem::path> lastIncludePaths;
-    if(lastScriptInfo && !GatherIncludePaths(   scriptDirectory,
-                                                *lastScriptInfo,
+    if(lastInfo && !GatherIncludePaths(   scriptDirectory,
+                                                *lastInfo,
                                                 profile,
                                                 {}, // Empty dependencies
                                                 lastIncludePaths))

Src/runcpp2/main.cpp

@@ -344,7 +344,7 @@ int main(int argc, char* argv[])
             ssLOG_ERROR("Failed reset user config");
             return -1;
         }
-        ssLOG_BASE("User config reset successful");
+        ssLOG_LINE("User config reset successful");
         return 0;
     }
 
@@ -355,7 +355,7 @@ int main(int argc, char* argv[])
             return -1;
         else
         {
-            ssLOG_BASE("Script template generated");
+            ssLOG_LINE("Script template generated");
             return 0;
         }
     }
@@ -415,12 +415,37 @@ int main(int argc, char* argv[])
             return -1;
         }
 
-        ghc::filesystem::file_time_type lastScriptWriteTime {};
+        int64_t lastSourceWriteTime = 0;
+        runcpp2::Data::ScriptInfo* lastParsedScriptInfo = nullptr;
+        
         while(true)
         {
-            runcpp2::Data::ScriptInfo* lastParsedScriptInfo = nullptr;
+            bool needsRunning = false;
+            int64_t currentWriteTime = 0;
 
-            if(ghc::filesystem::last_write_time(script, e) > lastScriptWriteTime)
+            runcpp2::PipelineResult result = 
+                runcpp2::GetLatestSourceWriteTime(  script,
+                                                    profiles,
+                                                    preferredProfile,
+                                                    lastParsedScriptInfo ? 
+                                                        *lastParsedScriptInfo : 
+                                                        runcpp2::Data::ScriptInfo(),
+                                                    currentWriteTime);
+
+            if(result != runcpp2::PipelineResult::SUCCESS)
+            {
+                ssLOG_ERROR("Failed to get latest source write time");
+                return -1;
+            }
+            
+            if(currentWriteTime > lastSourceWriteTime)
+            {
+                ssLOG_INFO("Source files have changed");
+                needsRunning = true;
+                lastSourceWriteTime = currentWriteTime;
+            }
+
+            if(needsRunning)
             {
                 int result = 0;
 
@@ -453,16 +478,36 @@ int main(int argc, char* argv[])
                     case runcpp2::PipelineResult::INVALID_PROFILE:
                     case runcpp2::PipelineResult::RUN_SCRIPT_FAILED:
                     case runcpp2::PipelineResult::INVALID_OPTION:
-                        ssLOG_BASE("Watching...");
+                        ssLOG_LINE("Watching...");
                         break;
                     case runcpp2::PipelineResult::SUCCESS:
-                        ssLOG_BASE("No error. Watching...");
+                        ssLOG_LINE("No error. Watching...");
                         break;
                 }
+                
+                //Upate the timestamp if we managed to parse the script info for the first time
+                if( !lastParsedScriptInfo && 
+                    pipelineResult != runcpp2::PipelineResult::INVALID_SCRIPT_INFO)
+                {
+                    runcpp2::PipelineResult result = 
+                        runcpp2::GetLatestSourceWriteTime(  script,
+                                                            profiles,
+                                                            preferredProfile,
+                                                            parsedScriptInfo,
+                                                            currentWriteTime);
+
+                    if(result != runcpp2::PipelineResult::SUCCESS)
+                    {
+                        ssLOG_ERROR("Failed to get latest source write time");
+                        return -1;
+                    }
+                    
+                    lastSourceWriteTime = currentWriteTime;
+                }
+                
+                lastParsedScriptInfo = &parsedScriptInfo;
             }
 
-            lastScriptWriteTime = ghc::filesystem::last_write_time(script, e);
-            lastParsedScriptInfo = &parsedScriptInfo;
             std::this_thread::sleep_for(std::chrono::seconds(5));
         }
     }
@@ -487,7 +532,7 @@ int main(int argc, char* argv[])
     }
 
     if(currentOptions.count(runcpp2::CmdOptions::CLEANUP) > 0)
-        ssLOG_BASE("Cleanup successful");
+        ssLOG_LINE("Cleanup successful");
 
     return result;
 }

Src/runcpp2/runcpp2.cpp

@@ -238,6 +238,70 @@ void runcpp2::SetLogLevel(const std::string& logLevel)
         ssLOG_ERROR("Invalid log level: " << logLevel);
 }
 
+runcpp2::PipelineResult 
+runcpp2::GetLatestSourceWriteTime(  const std::string& scriptPath,
+                                    const std::vector<Data::Profile>& profiles,
+                                    const std::string& configPreferredProfile,
+                                    const Data::ScriptInfo& scriptInfo,
+                                    int64_t& outWriteTime)
+{
+    INTERNAL_RUNCPP2_SAFE_START();
+    ssLOG_FUNC_DEBUG();
+
+    //Validate inputs and get paths
+    ghc::filesystem::path absoluteScriptPath;
+    ghc::filesystem::path scriptDirectory;
+    std::string scriptName;
+    
+    PipelineResult result = ValidateInputs( scriptPath, 
+                                            profiles, 
+                                            absoluteScriptPath,
+                                            scriptDirectory,
+                                            scriptName);
+    if(result != PipelineResult::SUCCESS)
+        return result;
+
+    std::error_code e;
+    if(!ghc::filesystem::exists(absoluteScriptPath, e))
+    {
+        ssLOG_ERROR("Script path " << absoluteScriptPath << " doesn't exist");
+        return PipelineResult::INVALID_SCRIPT_PATH;
+    }
+
+    outWriteTime = std::chrono::duration_cast<std::chrono::seconds>(
+        ghc::filesystem::last_write_time(absoluteScriptPath, e).time_since_epoch()).count();
+
+    std::vector<ghc::filesystem::path> sourceFiles;
+    if(GatherSourceFiles(   absoluteScriptPath, 
+                            scriptInfo, 
+                            profiles.at(GetPreferredProfileIndex(   scriptPath,
+                                                                    scriptInfo,
+                                                                    profiles,
+                                                                    configPreferredProfile)), 
+                            sourceFiles))
+    {
+        for(const ghc::filesystem::path& sourcePath : sourceFiles)
+        {
+            if(ghc::filesystem::exists(sourcePath, e))
+            {
+                ghc::filesystem::file_time_type currentWriteTime = 
+                    ghc::filesystem::last_write_time(sourcePath, e);
+                
+                using namespace std::chrono;
+                int64_t currentWriteTimeCount = 
+                    duration_cast<seconds>(currentWriteTime.time_since_epoch()).count();
+                
+                if(currentWriteTimeCount > outWriteTime)
+                    outWriteTime = currentWriteTimeCount;
+            }
+        }
+    }
+
+    return PipelineResult::SUCCESS;
+
+    INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);
+}
+
 runcpp2::PipelineResult 
 runcpp2::StartPipeline( const std::string& scriptPath, 
                         const std::vector<Data::Profile>& profiles,
@@ -349,7 +413,7 @@ runcpp2::StartPipeline( const std::string& scriptPath,
         if(result != PipelineResult::SUCCESS)
             return result;
 
-        if(recompileNeeded || !changedDependencies.empty() || relinkNeeded)
+        if(!lastScriptInfo || recompileNeeded || !changedDependencies.empty() || relinkNeeded)
             outScriptInfo = scriptInfo;
 
         std::vector<std::string> gatheredBinariesPaths;
@@ -473,6 +537,8 @@ runcpp2::StartPipeline( const std::string& scriptPath,
                 {
                     return PipelineResult::COMPILE_LINK_FAILED;
                 }
+                
+                return PipelineResult::SUCCESS;
             }
             else if(!CompileAndLinkScript(  buildDir,
                                             absoluteScriptPath,