bool readPresentation(SlideDeck* pSlideDeck,
std::string* pSlides,
std::string* pInitActions,
std::string* pSlideActions,
std::map<std::string,std::string>* pVars,
std::string* pErrMsg)
{
// look for slides and knit if we need to
FilePath rmdFile = presentation::state::filePath();
std::string ext = rmdFile.extensionLowerCase();
if (rmdFile.exists() && (ext != ".md"))
{
if (!performKnit(rmdFile, pErrMsg))
return false;
}
// look for slides markdown
FilePath slidesFile = rmdFile.parent().childPath(rmdFile.stem() + ".md");
if (!slidesFile.exists())
{
*pErrMsg = slidesFile.absolutePath() + " not found";
return false;
}
// parse the slides
Error error = pSlideDeck->readSlides(slidesFile);
if (error)
{
LOG_ERROR(error);
*pErrMsg = error.summary();
return false;
}
// render the slides
std::string revealConfig;
error = presentation::renderSlides(*pSlideDeck,
pSlides,
&revealConfig,
pInitActions,
pSlideActions);
if (error)
{
LOG_ERROR(error);
*pErrMsg = error.summary();
return false;
}
// build template variables
std::map<std::string,std::string>& vars = *pVars;
vars["title"] = pSlideDeck->title();
vars["slides"] = *pSlides;
vars["slides_css"] = resourceFiles().get("presentation/slides.css");
vars["r_highlight"] = resourceFiles().get("r_highlight.html");
vars["reveal_config"] = revealConfig;
vars["preamble"] = pSlideDeck->preamble();
return true;
}
Error mergeDicDeltaFile(const FilePath& dicDeltaPath)
{
// determine whether we are going to support affixes -- we do this for
// english only right now because we can correctly (by inspection) map
// the chromium numeric affix indicators (6 and 7) to the right
// hunspell example words. it's worth investigating whether we can do
// this for other languages as well
bool addAffixes = boost::algorithm::starts_with(dicDeltaPath.stem(),
"en_");
// read the file and strip the BOM
std::string contents;
Error error = core::readStringFromFile(dicDeltaPath, &contents);
if (error)
return error;
core::stripBOM(&contents);
// split into lines
std::vector<std::string> lines;
boost::algorithm::split(lines,
contents,
boost::algorithm::is_any_of("\n"));
// parse lines for words
bool added;
std::string word, affix, example;
BOOST_FOREACH(const std::string& line, lines)
{
if (parseDicDeltaLine(line, &word, &affix))
{
example = exampleWordForEnglishAffix(affix);
if (!example.empty() && addAffixes)
{
Error error = addWordWithAffix(word, example, &added);
if (error)
LOG_ERROR(error);
}
else
{
Error error = addWord(word, &added);
if (error)
LOG_ERROR(error);
}
}
}
return Success();
}
SEXP rs_pathInfo(SEXP pathSEXP)
{
try
{
// validate
if (r::sexp::length(pathSEXP) != 1)
{
throw r::exec::RErrorException(
"must pass a single file to get path info for");
}
std::string path;
Error error = r::sexp::extract(pathSEXP, &path);
if (error)
throw r::exec::RErrorException(r::endUserErrorMessage(error));
// resolve aliased path
FilePath filePath = module_context::resolveAliasedPath(path);
if (filePath.empty())
throw r::exec::RErrorException("invalid path: " + path);
// create path info vector (use json repsesentation to force convertion
// to VECSXP rather than STRSXP)
json::Object pathInfo;
pathInfo["path"] = filePath.absolutePath();
std::string parent = filePath.absolutePath();
FilePath parentPath = filePath.parent();
if (!parentPath.empty())
parent = parentPath.absolutePath();
pathInfo["directory"] = parent;
pathInfo["name"] = filePath.filename();
pathInfo["stem"] = filePath.stem();
pathInfo["extension"] = filePath.extension();
// return it
r::sexp::Protect rProtect;
return r::sexp::create(pathInfo, &rProtect);
}
catch(r::exec::RErrorException e)
{
r::exec::error(e.message());
}
CATCH_UNEXPECTED_EXCEPTION
return R_NilValue;
}
Error HunspellCustomDictionaries::add(const FilePath& dicPath) const
{
// validate .dic extension
if (!dicPath.hasExtensionLowerCase(".dic"))
{
return systemError(boost::system::errc::invalid_argument,
ERROR_LOCATION);
}
// remove existing with same name
std::string name = dicPath.stem();
Error error = remove(name);
if (error)
LOG_ERROR(error);
// add it
return dicPath.copy(dictionaryPath(name));
}
Error forwardSearch(const FilePath& rootFile,
const json::Object& sourceLocation,
json::Value* pPdfLocation)
{
// read params
std::string file;
int line, column;
bool fromClick;
Error error = json::readObject(sourceLocation,
"file", &file,
"line", &line,
"column", &column,
"from_click", &fromClick);
if (error)
return error;
// determine input file
FilePath inputFile = module_context::resolveAliasedPath(file);
// determine pdf
FilePath pdfFile = rootFile.parent().complete(rootFile.stem() + ".pdf");
core::tex::Synctex synctex;
if (synctex.parse(pdfFile))
{
core::tex::SourceLocation srcLoc(inputFile, line, column);
applyForwardConcordance(rootFile, &srcLoc);
core::tex::PdfLocation pdfLoc = synctex.forwardSearch(srcLoc);
*pPdfLocation = toJson(pdfFile, pdfLoc, fromClick);
}
else
{
*pPdfLocation = json::Value();
}
return Success();
}
void init(const FilePath& targetFilePath)
{
basePath_ = targetFilePath.parent().childPath(
targetFilePath.stem()).absolutePath();
}
FilePath ancillaryFilePath(const FilePath& texFilePath, const std::string& ext)
{
return texFilePath.parent().childPath(texFilePath.stem() + ext);
}
Error createSshKey(const json::JsonRpcRequest& request,
json::JsonRpcResponse* pResponse)
{
std::string path, type, passphrase;
bool overwrite;
Error error = json::readObjectParam(request.params, 0,
"path", &path,
"type", &type,
"passphrase", &passphrase,
"overwrite", &overwrite);
if (error)
return error;
#ifdef RSTUDIO_SERVER
// In server mode, passphrases are encrypted
using namespace rstudio::core::system::crypto;
error = rsaPrivateDecrypt(passphrase, &passphrase);
if (error)
return error;
#endif
// resolve key path
FilePath sshKeyPath = module_context::resolveAliasedPath(path);
FilePath sshPublicKeyPath = sshKeyPath.parent().complete(
sshKeyPath.stem() + ".pub");
if (sshKeyPath.exists() || sshPublicKeyPath.exists())
{
if (!overwrite)
{
json::Object resultJson;
resultJson["failed_key_exists"] = true;
pResponse->setResult(resultJson);
return Success();
}
else
{
Error error = sshKeyPath.removeIfExists();
if (error)
return error;
error = sshPublicKeyPath.removeIfExists();
if (error)
return error;
}
}
// compose a shell command to create the key
shell_utils::ShellCommand cmd("ssh-keygen");
// type
cmd << "-t" << type;
// passphrase (optional)
cmd << "-N";
if (!passphrase.empty())
cmd << passphrase;
else
cmd << std::string("");
// path
cmd << "-f" << sshKeyPath;
// process options
core::system::ProcessOptions options;
// detach the session so there is no terminal
#ifndef _WIN32
options.detachSession = true;
#endif
// customize the environment on Win32
#ifdef _WIN32
core::system::Options childEnv;
core::system::environment(&childEnv);
// set HOME to USERPROFILE
std::string userProfile = core::system::getenv(childEnv, "USERPROFILE");
core::system::setenv(&childEnv, "HOME", userProfile);
// add msys_ssh to path
core::system::addToPath(&childEnv,
session::options().msysSshPath().absolutePath());
options.environment = childEnv;
#endif
// run it
core::system::ProcessResult result;
error = runCommand(shell_utils::sendStdErrToStdOut(cmd),
options,
&result);
if (error)
return error;
// return exit code and output
json::Object resultJson;
resultJson["failed_key_exists"] = false;
resultJson["exit_status"] = result.exitStatus;
resultJson["output"] = result.stdOut;
pResponse->setResult(resultJson);
return Success();
}