use .nb.html over local cache if newer (e.g. from vcs)

Author: jmcphers

src/cpp/session/modules/SessionRmdNotebook.R

@@ -14,11 +14,7 @@
 #
 assign(".rs.notebookVersion", envir = .rs.toolsEnv(), "1.0")
 
-.rs.addFunction("extractRmdFromNotebook", function(input, output) 
-{
-   if (Encoding(input) == "unknown")  Encoding(input) <- "UTF-8"
-   if (Encoding(output) == "unknown") Encoding(output) <- "UTF-8"
-   
+.rs.addFunction("parseRmdFromNotebook", function(input, output) {
    # extract rmd contents and populate file
    contents <- "# Failed to parse notebook"
    parsed <- try(rmarkdown::parse_html_notebook(input), silent = TRUE)
@@ -28,6 +24,27 @@ assign(".rs.notebookVersion", envir = .rs.toolsEnv(), "1.0")
       contents <- parsed$rmd
    }
    cat(contents, file = output, sep = "\n")
+})
+
+.rs.addFunction("testNotebookRmdMatches", function(rmd, notebook) {
+   # parse the notebook to get the text of the contained R markdown doc
+   parsed <- try(rmarkdown::parse_html_notebook(notebook), silent = TRUE)
+   if (inherits(parsed, "try-error") || is.null(parsed$rmd)) {
+    return(.rs.scalar(FALSE))
+   }
+
+   # compare with the contents of the R markdown file
+   rmdContents <- readLines(rmd)
+   return(identical(parsed$rmd, rmdContents))
+})
+
+.rs.addFunction("extractRmdFromNotebook", function(input, output) 
+{
+   if (Encoding(input) == "unknown")  Encoding(input) <- "UTF-8"
+   if (Encoding(output) == "unknown") Encoding(output) <- "UTF-8"
+
+   # parse R Markdown from notebook and write it to the requested file
+   .rs.parseRmdFromNotebook(input, output)
 
    # extract and populate cache
    status <- try(.rs.hydrateCacheFromNotebook(input), silent = TRUE)

src/cpp/session/modules/rmarkdown/NotebookCache.cpp

@@ -236,31 +236,73 @@ void onDocAdded(const std::string& id)
    if (docPath.extensionLowerCase() != ".rmd")
       return;
 
-   FilePath cachePath = chunkCacheFolder(path, id);
+   // find the cache (test for saved) 
+   FilePath cachePath = chunkCacheFolder(path, id, notebookCtxId());
+   if (!cachePath.exists())
+      cachePath = chunkCacheFolder(path, id, kSavedCtx);
+
    FilePath notebookPath = docPath.parent().complete(docPath.stem() + 
          kNotebookExt);
 
-   // clean up incompatible cache versions (as we're about to invalidate them
-   // by mutating the document without updating them) 
-   if (cachePath.exists())
-   {
-      std::vector<FilePath> versions;
-      cachePath.children(&versions);
-      BOOST_FOREACH(const FilePath& version, versions)
-      {
-         if (version.isDirectory() && version.filename() != kCacheVersion)
-         {
-            error = version.remove();
-            if (error)
-               LOG_ERROR(error);
-         }
-      }
-   }
-
    // if the cache doesn't exist but we have a notebook file, hydrate from that
    // file
    if (!cachePath.exists() && notebookPath.exists())
    {
+      error = r::exec::RFunction(".rs.hydrateCacheFromNotebook", 
+            notebookPath.absolutePath()).call();
+      if (error)
+         LOG_ERROR(error);
+      return;
+   }
+
+   // if both the local cache and the notebook cache exist, we need to decide
+   // which to load
+   if (cachePath.exists() && notebookPath.exists())
+   {
+      // get the dates first--in no case will we use the notebook over the
+      // local cache if the local cache is newer (this will be the case most
+      // of the time). we want to check this first because it's cheap; further
+      // tests will require us to test the caches for compatibility, which is
+      // more expensive.
+     
+      // find the chunk definition file 
+      FilePath chunkDefs = cachePath.complete(kNotebookChunkDefFilename);
+      if (!chunkDefs.exists())
+         return;
+
+      std::time_t localCacheTime = chunkDefs.lastWriteTime();
+      std::time_t nbCacheTime = notebookPath.lastWriteTime();
+
+      if (localCacheTime >= nbCacheTime)
+         return;
+
+      // if we got this far, it means that the notebook cache looks newer than
+      // our cache -- test to see whether it's compatible
+      bool matches = false;
+      error = r::exec::RFunction(".rs.testNotebookRmdMatches", 
+            docPath.absolutePath(), notebookPath.absolutePath()).call(&matches);
+      if (error)
+      {
+         LOG_ERROR(error);
+         return;
+      }
+      
+      if (!matches)
+      {
+         // the notebook cache looks newer but it isn't aligned with the .Rmd,
+         // so we can't use it
+         return;
+      }
+
+      // if we got this far, we have matching newer notebook cache. blow away
+      // our stale local cache and rehydrate from the notebook cache.
+      error = cachePath.remove();
+      if (error)
+      {
+         LOG_ERROR(error);
+         return;
+      }
+
       error = r::exec::RFunction(".rs.hydrateCacheFromNotebook", 
             notebookPath.absolutePath()).call();
       if (error)

src/cpp/session/modules/rmarkdown/SessionRmdNotebook.cpp

@@ -238,6 +238,16 @@ Error createNotebookFromCache(const json::JsonRpcRequest& request,
       LOG_ERROR(error);
       return error;
    }
+
+   // bump the write time on our local chunk definition file so that it matches
+   // the notebook file; this prevents us from thinking that the .nb.html file
+   // we just wrote is ahead of the local cache.
+   FilePath outputFile = module_context::resolveAliasedPath(outputPath);
+   FilePath chunkDefsFile = chunkDefinitionsPath(
+         module_context::resolveAliasedPath(rmdPath), kSavedCtx);
+   if (chunkDefsFile.exists() && 
+       chunkDefsFile.lastWriteTime() < outputFile.lastWriteTime())
+      chunkDefsFile.setLastWriteTime(outputFile.lastWriteTime());
 
    return Success();
 }