diff --git a/.Rprofile b/.Rprofile
new file mode 100644
index 0000000..81b960f
--- /dev/null
+++ b/.Rprofile
@@ -0,0 +1 @@
+source("renv/activate.R")
diff --git a/.gitignore b/.gitignore
index e75435c..3e54170 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,4 @@ po/*~
# RStudio Connect folder
rsconnect/
+template.html
diff --git a/header.html b/header.html
index ce86c94..3ad4b7a 100644
--- a/header.html
+++ b/header.html
@@ -1,3 +1,3 @@
- 
+
\ No newline at end of file
diff --git a/renv.lock b/renv.lock
new file mode 100644
index 0000000..7887560
--- /dev/null
+++ b/renv.lock
@@ -0,0 +1,353 @@
+{
+ "R": {
+ "Version": "4.2.1",
+ "Repositories": [
+ {
+ "Name": "CRAN",
+ "URL": "https://cran.rstudio.com"
+ }
+ ]
+ },
+ "Packages": {
+ "R6": {
+ "Package": "R6",
+ "Version": "2.5.1",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "470851b6d5d0ac559e9d01bb352b4021",
+ "Requirements": []
+ },
+ "askpass": {
+ "Package": "askpass",
+ "Version": "1.1",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "e8a22846fff485f0be3770c2da758713",
+ "Requirements": [
+ "sys"
+ ]
+ },
+ "base64enc": {
+ "Package": "base64enc",
+ "Version": "0.1-3",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "543776ae6848fde2f48ff3816d0628bc",
+ "Requirements": []
+ },
+ "bslib": {
+ "Package": "bslib",
+ "Version": "0.4.0",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "be5ee090716ce1671be6cd5d7c34d091",
+ "Requirements": [
+ "cachem",
+ "htmltools",
+ "jquerylib",
+ "jsonlite",
+ "memoise",
+ "rlang",
+ "sass"
+ ]
+ },
+ "cachem": {
+ "Package": "cachem",
+ "Version": "1.0.6",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "648c5b3d71e6a37e3043617489a0a0e9",
+ "Requirements": [
+ "fastmap",
+ "rlang"
+ ]
+ },
+ "curl": {
+ "Package": "curl",
+ "Version": "4.3.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "022c42d49c28e95d69ca60446dbabf88",
+ "Requirements": []
+ },
+ "digest": {
+ "Package": "digest",
+ "Version": "0.6.29",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "cf6b206a045a684728c3267ef7596190",
+ "Requirements": []
+ },
+ "ellipsis": {
+ "Package": "ellipsis",
+ "Version": "0.3.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "bb0eec2fe32e88d9e2836c2f73ea2077",
+ "Requirements": [
+ "rlang"
+ ]
+ },
+ "evaluate": {
+ "Package": "evaluate",
+ "Version": "0.15",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "699a7a93d08c962d9f8950b2d7a227f1",
+ "Requirements": []
+ },
+ "fastmap": {
+ "Package": "fastmap",
+ "Version": "1.1.0",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "77bd60a6157420d4ffa93b27cf6a58b8",
+ "Requirements": []
+ },
+ "fs": {
+ "Package": "fs",
+ "Version": "1.5.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "7c89603d81793f0d5486d91ab1fc6f1d",
+ "Requirements": []
+ },
+ "glue": {
+ "Package": "glue",
+ "Version": "1.6.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "4f2596dfb05dac67b9dc558e5c6fba2e",
+ "Requirements": []
+ },
+ "highr": {
+ "Package": "highr",
+ "Version": "0.9",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "8eb36c8125038e648e5d111c0d7b2ed4",
+ "Requirements": [
+ "xfun"
+ ]
+ },
+ "htmltools": {
+ "Package": "htmltools",
+ "Version": "0.5.4",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "9d27e99cc90bd701c0a7a63e5923f9b7",
+ "Requirements": [
+ "base64enc",
+ "digest",
+ "ellipsis",
+ "fastmap",
+ "rlang"
+ ]
+ },
+ "httr": {
+ "Package": "httr",
+ "Version": "1.4.3",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "88d1b310583777edf01ccd1216fb0b2b",
+ "Requirements": [
+ "R6",
+ "curl",
+ "jsonlite",
+ "mime",
+ "openssl"
+ ]
+ },
+ "jquerylib": {
+ "Package": "jquerylib",
+ "Version": "0.1.4",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "5aab57a3bd297eee1c1d862735972182",
+ "Requirements": [
+ "htmltools"
+ ]
+ },
+ "jsonlite": {
+ "Package": "jsonlite",
+ "Version": "1.8.0",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "d07e729b27b372429d42d24d503613a0",
+ "Requirements": []
+ },
+ "knitr": {
+ "Package": "knitr",
+ "Version": "1.39",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "029ab7c4badd3cf8af69016b2ba27493",
+ "Requirements": [
+ "evaluate",
+ "highr",
+ "stringr",
+ "xfun",
+ "yaml"
+ ]
+ },
+ "magrittr": {
+ "Package": "magrittr",
+ "Version": "2.0.3",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "7ce2733a9826b3aeb1775d56fd305472",
+ "Requirements": []
+ },
+ "memoise": {
+ "Package": "memoise",
+ "Version": "2.0.1",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "e2817ccf4a065c5d9d7f2cfbe7c1d78c",
+ "Requirements": [
+ "cachem",
+ "rlang"
+ ]
+ },
+ "mime": {
+ "Package": "mime",
+ "Version": "0.12",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "18e9c28c1d3ca1560ce30658b22ce104",
+ "Requirements": []
+ },
+ "openssl": {
+ "Package": "openssl",
+ "Version": "2.0.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "6d3bef2e305f55c705c674653c7d7d3d",
+ "Requirements": [
+ "askpass"
+ ]
+ },
+ "rappdirs": {
+ "Package": "rappdirs",
+ "Version": "0.3.3",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "5e3c5dc0b071b21fa128676560dbe94d",
+ "Requirements": []
+ },
+ "renv": {
+ "Package": "renv",
+ "Version": "0.15.5",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "6a38294e7d12f5d8e656b08c5bd8ae34",
+ "Requirements": []
+ },
+ "rlang": {
+ "Package": "rlang",
+ "Version": "1.0.4",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "6539dd8c651e67e3b55b5ffea106362b",
+ "Requirements": []
+ },
+ "rmarkdown": {
+ "Package": "rmarkdown",
+ "Version": "2.17",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "e97c8be593e010f93520e8215c0f9189",
+ "Requirements": [
+ "bslib",
+ "evaluate",
+ "htmltools",
+ "jquerylib",
+ "jsonlite",
+ "knitr",
+ "stringr",
+ "tinytex",
+ "xfun",
+ "yaml"
+ ]
+ },
+ "sass": {
+ "Package": "sass",
+ "Version": "0.4.2",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "1b191143d7d3444d504277843f3a95fe",
+ "Requirements": [
+ "R6",
+ "fs",
+ "htmltools",
+ "rappdirs",
+ "rlang"
+ ]
+ },
+ "shroomDK": {
+ "Package": "shroomDK",
+ "Version": "0.1.1",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "28b8ac7aa1d889d635c3ac3c5150b11a",
+ "Requirements": [
+ "httr",
+ "jsonlite"
+ ]
+ },
+ "stringi": {
+ "Package": "stringi",
+ "Version": "1.7.8",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "a68b980681bcbc84c7a67003fa796bfb",
+ "Requirements": []
+ },
+ "stringr": {
+ "Package": "stringr",
+ "Version": "1.4.0",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "0759e6b6c0957edb1311028a49a35e76",
+ "Requirements": [
+ "glue",
+ "magrittr",
+ "stringi"
+ ]
+ },
+ "sys": {
+ "Package": "sys",
+ "Version": "3.4",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "b227d13e29222b4574486cfcbde077fa",
+ "Requirements": []
+ },
+ "tinytex": {
+ "Package": "tinytex",
+ "Version": "0.42",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "7629c6c1540835d5248e6e7df265fa74",
+ "Requirements": [
+ "xfun"
+ ]
+ },
+ "xfun": {
+ "Package": "xfun",
+ "Version": "0.31",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "a318c6f752b8dcfe9fb74d897418ab2b",
+ "Requirements": []
+ },
+ "yaml": {
+ "Package": "yaml",
+ "Version": "2.3.5",
+ "Source": "Repository",
+ "Repository": "CRAN",
+ "Hash": "458bb38374d73bf83b1bb85e353da200",
+ "Requirements": []
+ }
+ }
+}
diff --git a/renv/.gitignore b/renv/.gitignore
new file mode 100644
index 0000000..275e4ca
--- /dev/null
+++ b/renv/.gitignore
@@ -0,0 +1,6 @@
+library/
+local/
+cellar/
+lock/
+python/
+staging/
diff --git a/renv/activate.R b/renv/activate.R
new file mode 100644
index 0000000..72c0818
--- /dev/null
+++ b/renv/activate.R
@@ -0,0 +1,942 @@
+
+local({
+
+ # the requested version of renv
+ version <- "0.15.5"
+
+ # the project directory
+ project <- getwd()
+
+ # figure out whether the autoloader is enabled
+ enabled <- local({
+
+ # first, check config option
+ override <- getOption("renv.config.autoloader.enabled")
+ if (!is.null(override))
+ return(override)
+
+ # next, check environment variables
+ # TODO: prefer using the configuration one in the future
+ envvars <- c(
+ "RENV_CONFIG_AUTOLOADER_ENABLED",
+ "RENV_AUTOLOADER_ENABLED",
+ "RENV_ACTIVATE_PROJECT"
+ )
+
+ for (envvar in envvars) {
+ envval <- Sys.getenv(envvar, unset = NA)
+ if (!is.na(envval))
+ return(tolower(envval) %in% c("true", "t", "1"))
+ }
+
+ # enable by default
+ TRUE
+
+ })
+
+ if (!enabled)
+ return(FALSE)
+
+ # avoid recursion
+ if (identical(getOption("renv.autoloader.running"), TRUE)) {
+ warning("ignoring recursive attempt to run renv autoloader")
+ return(invisible(TRUE))
+ }
+
+ # signal that we're loading renv during R startup
+ options(renv.autoloader.running = TRUE)
+ on.exit(options(renv.autoloader.running = NULL), add = TRUE)
+
+ # signal that we've consented to use renv
+ options(renv.consent = TRUE)
+
+ # load the 'utils' package eagerly -- this ensures that renv shims, which
+ # mask 'utils' packages, will come first on the search path
+ library(utils, lib.loc = .Library)
+
+ # unload renv if it's already been loaded
+ if ("renv" %in% loadedNamespaces())
+ unloadNamespace("renv")
+
+ # load bootstrap tools
+ `%||%` <- function(x, y) {
+ if (is.environment(x) || length(x)) x else y
+ }
+
+ bootstrap <- function(version, library) {
+
+ # attempt to download renv
+ tarball <- tryCatch(renv_bootstrap_download(version), error = identity)
+ if (inherits(tarball, "error"))
+ stop("failed to download renv ", version)
+
+ # now attempt to install
+ status <- tryCatch(renv_bootstrap_install(version, tarball, library), error = identity)
+ if (inherits(status, "error"))
+ stop("failed to install renv ", version)
+
+ }
+
+ renv_bootstrap_tests_running <- function() {
+ getOption("renv.tests.running", default = FALSE)
+ }
+
+ renv_bootstrap_repos <- function() {
+
+ # check for repos override
+ repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA)
+ if (!is.na(repos))
+ return(repos)
+
+ # check for lockfile repositories
+ repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity)
+ if (!inherits(repos, "error") && length(repos))
+ return(repos)
+
+ # if we're testing, re-use the test repositories
+ if (renv_bootstrap_tests_running())
+ return(getOption("renv.tests.repos"))
+
+ # retrieve current repos
+ repos <- getOption("repos")
+
+ # ensure @CRAN@ entries are resolved
+ repos[repos == "@CRAN@"] <- getOption(
+ "renv.repos.cran",
+ "https://cloud.r-project.org"
+ )
+
+ # add in renv.bootstrap.repos if set
+ default <- c(FALLBACK = "https://cloud.r-project.org")
+ extra <- getOption("renv.bootstrap.repos", default = default)
+ repos <- c(repos, extra)
+
+ # remove duplicates that might've snuck in
+ dupes <- duplicated(repos) | duplicated(names(repos))
+ repos[!dupes]
+
+ }
+
+ renv_bootstrap_repos_lockfile <- function() {
+
+ lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock")
+ if (!file.exists(lockpath))
+ return(NULL)
+
+ lockfile <- tryCatch(renv_json_read(lockpath), error = identity)
+ if (inherits(lockfile, "error")) {
+ warning(lockfile)
+ return(NULL)
+ }
+
+ repos <- lockfile$R$Repositories
+ if (length(repos) == 0)
+ return(NULL)
+
+ keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1))
+ vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1))
+ names(vals) <- keys
+
+ return(vals)
+
+ }
+
+ renv_bootstrap_download <- function(version) {
+
+ # if the renv version number has 4 components, assume it must
+ # be retrieved via github
+ nv <- numeric_version(version)
+ components <- unclass(nv)[[1]]
+
+ # if this appears to be a development version of 'renv', we'll
+ # try to restore from github
+ dev <- length(components) == 4L
+
+ # begin collecting different methods for finding renv
+ methods <- c(
+ renv_bootstrap_download_tarball,
+ if (dev)
+ renv_bootstrap_download_github
+ else c(
+ renv_bootstrap_download_cran_latest,
+ renv_bootstrap_download_cran_archive
+ )
+ )
+
+ for (method in methods) {
+ path <- tryCatch(method(version), error = identity)
+ if (is.character(path) && file.exists(path))
+ return(path)
+ }
+
+ stop("failed to download renv ", version)
+
+ }
+
+ renv_bootstrap_download_impl <- function(url, destfile) {
+
+ mode <- "wb"
+
+ # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715
+ fixup <-
+ Sys.info()[["sysname"]] == "Windows" &&
+ substring(url, 1L, 5L) == "file:"
+
+ if (fixup)
+ mode <- "w+b"
+
+ utils::download.file(
+ url = url,
+ destfile = destfile,
+ mode = mode,
+ quiet = TRUE
+ )
+
+ }
+
+ renv_bootstrap_download_cran_latest <- function(version) {
+
+ spec <- renv_bootstrap_download_cran_latest_find(version)
+
+ message("* Downloading renv ", version, " ... ", appendLF = FALSE)
+
+ type <- spec$type
+ repos <- spec$repos
+
+ info <- tryCatch(
+ utils::download.packages(
+ pkgs = "renv",
+ destdir = tempdir(),
+ repos = repos,
+ type = type,
+ quiet = TRUE
+ ),
+ condition = identity
+ )
+
+ if (inherits(info, "condition")) {
+ message("FAILED")
+ return(FALSE)
+ }
+
+ # report success and return
+ message("OK (downloaded ", type, ")")
+ info[1, 2]
+
+ }
+
+ renv_bootstrap_download_cran_latest_find <- function(version) {
+
+ # check whether binaries are supported on this system
+ binary <-
+ getOption("renv.bootstrap.binary", default = TRUE) &&
+ !identical(.Platform$pkgType, "source") &&
+ !identical(getOption("pkgType"), "source") &&
+ Sys.info()[["sysname"]] %in% c("Darwin", "Windows")
+
+ types <- c(if (binary) "binary", "source")
+
+ # iterate over types + repositories
+ for (type in types) {
+ for (repos in renv_bootstrap_repos()) {
+
+ # retrieve package database
+ db <- tryCatch(
+ as.data.frame(
+ utils::available.packages(type = type, repos = repos),
+ stringsAsFactors = FALSE
+ ),
+ error = identity
+ )
+
+ if (inherits(db, "error"))
+ next
+
+ # check for compatible entry
+ entry <- db[db$Package %in% "renv" & db$Version %in% version, ]
+ if (nrow(entry) == 0)
+ next
+
+ # found it; return spec to caller
+ spec <- list(entry = entry, type = type, repos = repos)
+ return(spec)
+
+ }
+ }
+
+ # if we got here, we failed to find renv
+ fmt <- "renv %s is not available from your declared package repositories"
+ stop(sprintf(fmt, version))
+
+ }
+
+ renv_bootstrap_download_cran_archive <- function(version) {
+
+ name <- sprintf("renv_%s.tar.gz", version)
+ repos <- renv_bootstrap_repos()
+ urls <- file.path(repos, "src/contrib/Archive/renv", name)
+ destfile <- file.path(tempdir(), name)
+
+ message("* Downloading renv ", version, " ... ", appendLF = FALSE)
+
+ for (url in urls) {
+
+ status <- tryCatch(
+ renv_bootstrap_download_impl(url, destfile),
+ condition = identity
+ )
+
+ if (identical(status, 0L)) {
+ message("OK")
+ return(destfile)
+ }
+
+ }
+
+ message("FAILED")
+ return(FALSE)
+
+ }
+
+ renv_bootstrap_download_tarball <- function(version) {
+
+ # if the user has provided the path to a tarball via
+ # an environment variable, then use it
+ tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA)
+ if (is.na(tarball))
+ return()
+
+ # allow directories
+ info <- file.info(tarball, extra_cols = FALSE)
+ if (identical(info$isdir, TRUE)) {
+ name <- sprintf("renv_%s.tar.gz", version)
+ tarball <- file.path(tarball, name)
+ }
+
+ # bail if it doesn't exist
+ if (!file.exists(tarball)) {
+
+ # let the user know we weren't able to honour their request
+ fmt <- "* RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist."
+ msg <- sprintf(fmt, tarball)
+ warning(msg)
+
+ # bail
+ return()
+
+ }
+
+ fmt <- "* Bootstrapping with tarball at path '%s'."
+ msg <- sprintf(fmt, tarball)
+ message(msg)
+
+ tarball
+
+ }
+
+ renv_bootstrap_download_github <- function(version) {
+
+ enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE")
+ if (!identical(enabled, "TRUE"))
+ return(FALSE)
+
+ # prepare download options
+ pat <- Sys.getenv("GITHUB_PAT")
+ if (nzchar(Sys.which("curl")) && nzchar(pat)) {
+ fmt <- "--location --fail --header \"Authorization: token %s\""
+ extra <- sprintf(fmt, pat)
+ saved <- options("download.file.method", "download.file.extra")
+ options(download.file.method = "curl", download.file.extra = extra)
+ on.exit(do.call(base::options, saved), add = TRUE)
+ } else if (nzchar(Sys.which("wget")) && nzchar(pat)) {
+ fmt <- "--header=\"Authorization: token %s\""
+ extra <- sprintf(fmt, pat)
+ saved <- options("download.file.method", "download.file.extra")
+ options(download.file.method = "wget", download.file.extra = extra)
+ on.exit(do.call(base::options, saved), add = TRUE)
+ }
+
+ message("* Downloading renv ", version, " from GitHub ... ", appendLF = FALSE)
+
+ url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version)
+ name <- sprintf("renv_%s.tar.gz", version)
+ destfile <- file.path(tempdir(), name)
+
+ status <- tryCatch(
+ renv_bootstrap_download_impl(url, destfile),
+ condition = identity
+ )
+
+ if (!identical(status, 0L)) {
+ message("FAILED")
+ return(FALSE)
+ }
+
+ message("OK")
+ return(destfile)
+
+ }
+
+ renv_bootstrap_install <- function(version, tarball, library) {
+
+ # attempt to install it into project library
+ message("* Installing renv ", version, " ... ", appendLF = FALSE)
+ dir.create(library, showWarnings = FALSE, recursive = TRUE)
+
+ # invoke using system2 so we can capture and report output
+ bin <- R.home("bin")
+ exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R"
+ r <- file.path(bin, exe)
+
+ args <- c(
+ "--vanilla", "CMD", "INSTALL", "--no-multiarch",
+ "-l", shQuote(path.expand(library)),
+ shQuote(path.expand(tarball))
+ )
+
+ output <- system2(r, args, stdout = TRUE, stderr = TRUE)
+ message("Done!")
+
+ # check for successful install
+ status <- attr(output, "status")
+ if (is.numeric(status) && !identical(status, 0L)) {
+ header <- "Error installing renv:"
+ lines <- paste(rep.int("=", nchar(header)), collapse = "")
+ text <- c(header, lines, output)
+ writeLines(text, con = stderr())
+ }
+
+ status
+
+ }
+
+ renv_bootstrap_platform_prefix <- function() {
+
+ # construct version prefix
+ version <- paste(R.version$major, R.version$minor, sep = ".")
+ prefix <- paste("R", numeric_version(version)[1, 1:2], sep = "-")
+
+ # include SVN revision for development versions of R
+ # (to avoid sharing platform-specific artefacts with released versions of R)
+ devel <-
+ identical(R.version[["status"]], "Under development (unstable)") ||
+ identical(R.version[["nickname"]], "Unsuffered Consequences")
+
+ if (devel)
+ prefix <- paste(prefix, R.version[["svn rev"]], sep = "-r")
+
+ # build list of path components
+ components <- c(prefix, R.version$platform)
+
+ # include prefix if provided by user
+ prefix <- renv_bootstrap_platform_prefix_impl()
+ if (!is.na(prefix) && nzchar(prefix))
+ components <- c(prefix, components)
+
+ # build prefix
+ paste(components, collapse = "/")
+
+ }
+
+ renv_bootstrap_platform_prefix_impl <- function() {
+
+ # if an explicit prefix has been supplied, use it
+ prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA)
+ if (!is.na(prefix))
+ return(prefix)
+
+ # if the user has requested an automatic prefix, generate it
+ auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA)
+ if (auto %in% c("TRUE", "True", "true", "1"))
+ return(renv_bootstrap_platform_prefix_auto())
+
+ # empty string on failure
+ ""
+
+ }
+
+ renv_bootstrap_platform_prefix_auto <- function() {
+
+ prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity)
+ if (inherits(prefix, "error") || prefix %in% "unknown") {
+
+ msg <- paste(
+ "failed to infer current operating system",
+ "please file a bug report at https://github.com/rstudio/renv/issues",
+ sep = "; "
+ )
+
+ warning(msg)
+
+ }
+
+ prefix
+
+ }
+
+ renv_bootstrap_platform_os <- function() {
+
+ sysinfo <- Sys.info()
+ sysname <- sysinfo[["sysname"]]
+
+ # handle Windows + macOS up front
+ if (sysname == "Windows")
+ return("windows")
+ else if (sysname == "Darwin")
+ return("macos")
+
+ # check for os-release files
+ for (file in c("/etc/os-release", "/usr/lib/os-release"))
+ if (file.exists(file))
+ return(renv_bootstrap_platform_os_via_os_release(file, sysinfo))
+
+ # check for redhat-release files
+ if (file.exists("/etc/redhat-release"))
+ return(renv_bootstrap_platform_os_via_redhat_release())
+
+ "unknown"
+
+ }
+
+ renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) {
+
+ # read /etc/os-release
+ release <- utils::read.table(
+ file = file,
+ sep = "=",
+ quote = c("\"", "'"),
+ col.names = c("Key", "Value"),
+ comment.char = "#",
+ stringsAsFactors = FALSE
+ )
+
+ vars <- as.list(release$Value)
+ names(vars) <- release$Key
+
+ # get os name
+ os <- tolower(sysinfo[["sysname"]])
+
+ # read id
+ id <- "unknown"
+ for (field in c("ID", "ID_LIKE")) {
+ if (field %in% names(vars) && nzchar(vars[[field]])) {
+ id <- vars[[field]]
+ break
+ }
+ }
+
+ # read version
+ version <- "unknown"
+ for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) {
+ if (field %in% names(vars) && nzchar(vars[[field]])) {
+ version <- vars[[field]]
+ break
+ }
+ }
+
+ # join together
+ paste(c(os, id, version), collapse = "-")
+
+ }
+
+ renv_bootstrap_platform_os_via_redhat_release <- function() {
+
+ # read /etc/redhat-release
+ contents <- readLines("/etc/redhat-release", warn = FALSE)
+
+ # infer id
+ id <- if (grepl("centos", contents, ignore.case = TRUE))
+ "centos"
+ else if (grepl("redhat", contents, ignore.case = TRUE))
+ "redhat"
+ else
+ "unknown"
+
+ # try to find a version component (very hacky)
+ version <- "unknown"
+
+ parts <- strsplit(contents, "[[:space:]]")[[1L]]
+ for (part in parts) {
+
+ nv <- tryCatch(numeric_version(part), error = identity)
+ if (inherits(nv, "error"))
+ next
+
+ version <- nv[1, 1]
+ break
+
+ }
+
+ paste(c("linux", id, version), collapse = "-")
+
+ }
+
+ renv_bootstrap_library_root_name <- function(project) {
+
+ # use project name as-is if requested
+ asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE")
+ if (asis)
+ return(basename(project))
+
+ # otherwise, disambiguate based on project's path
+ id <- substring(renv_bootstrap_hash_text(project), 1L, 8L)
+ paste(basename(project), id, sep = "-")
+
+ }
+
+ renv_bootstrap_library_root <- function(project) {
+
+ prefix <- renv_bootstrap_profile_prefix()
+
+ path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA)
+ if (!is.na(path))
+ return(paste(c(path, prefix), collapse = "/"))
+
+ path <- renv_bootstrap_library_root_impl(project)
+ if (!is.null(path)) {
+ name <- renv_bootstrap_library_root_name(project)
+ return(paste(c(path, prefix, name), collapse = "/"))
+ }
+
+ renv_bootstrap_paths_renv("library", project = project)
+
+ }
+
+ renv_bootstrap_library_root_impl <- function(project) {
+
+ root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA)
+ if (!is.na(root))
+ return(root)
+
+ type <- renv_bootstrap_project_type(project)
+ if (identical(type, "package")) {
+ userdir <- renv_bootstrap_user_dir()
+ return(file.path(userdir, "library"))
+ }
+
+ }
+
+ renv_bootstrap_validate_version <- function(version) {
+
+ loadedversion <- utils::packageDescription("renv", fields = "Version")
+ if (version == loadedversion)
+ return(TRUE)
+
+ # assume four-component versions are from GitHub; three-component
+ # versions are from CRAN
+ components <- strsplit(loadedversion, "[.-]")[[1]]
+ remote <- if (length(components) == 4L)
+ paste("rstudio/renv", loadedversion, sep = "@")
+ else
+ paste("renv", loadedversion, sep = "@")
+
+ fmt <- paste(
+ "renv %1$s was loaded from project library, but this project is configured to use renv %2$s.",
+ "Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile.",
+ "Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library.",
+ sep = "\n"
+ )
+
+ msg <- sprintf(fmt, loadedversion, version, remote)
+ warning(msg, call. = FALSE)
+
+ FALSE
+
+ }
+
+ renv_bootstrap_hash_text <- function(text) {
+
+ hashfile <- tempfile("renv-hash-")
+ on.exit(unlink(hashfile), add = TRUE)
+
+ writeLines(text, con = hashfile)
+ tools::md5sum(hashfile)
+
+ }
+
+ renv_bootstrap_load <- function(project, libpath, version) {
+
+ # try to load renv from the project library
+ if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE))
+ return(FALSE)
+
+ # warn if the version of renv loaded does not match
+ renv_bootstrap_validate_version(version)
+
+ # load the project
+ renv::load(project)
+
+ TRUE
+
+ }
+
+ renv_bootstrap_profile_load <- function(project) {
+
+ # if RENV_PROFILE is already set, just use that
+ profile <- Sys.getenv("RENV_PROFILE", unset = NA)
+ if (!is.na(profile) && nzchar(profile))
+ return(profile)
+
+ # check for a profile file (nothing to do if it doesn't exist)
+ path <- renv_bootstrap_paths_renv("profile", profile = FALSE)
+ if (!file.exists(path))
+ return(NULL)
+
+ # read the profile, and set it if it exists
+ contents <- readLines(path, warn = FALSE)
+ if (length(contents) == 0L)
+ return(NULL)
+
+ # set RENV_PROFILE
+ profile <- contents[[1L]]
+ if (!profile %in% c("", "default"))
+ Sys.setenv(RENV_PROFILE = profile)
+
+ profile
+
+ }
+
+ renv_bootstrap_profile_prefix <- function() {
+ profile <- renv_bootstrap_profile_get()
+ if (!is.null(profile))
+ return(file.path("profiles", profile, "renv"))
+ }
+
+ renv_bootstrap_profile_get <- function() {
+ profile <- Sys.getenv("RENV_PROFILE", unset = "")
+ renv_bootstrap_profile_normalize(profile)
+ }
+
+ renv_bootstrap_profile_set <- function(profile) {
+ profile <- renv_bootstrap_profile_normalize(profile)
+ if (is.null(profile))
+ Sys.unsetenv("RENV_PROFILE")
+ else
+ Sys.setenv(RENV_PROFILE = profile)
+ }
+
+ renv_bootstrap_profile_normalize <- function(profile) {
+
+ if (is.null(profile) || profile %in% c("", "default"))
+ return(NULL)
+
+ profile
+
+ }
+
+ renv_bootstrap_path_absolute <- function(path) {
+
+ substr(path, 1L, 1L) %in% c("~", "/", "\\") || (
+ substr(path, 1L, 1L) %in% c(letters, LETTERS) &&
+ substr(path, 2L, 3L) %in% c(":/", ":\\")
+ )
+
+ }
+
+ renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) {
+ renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv")
+ root <- if (renv_bootstrap_path_absolute(renv)) NULL else project
+ prefix <- if (profile) renv_bootstrap_profile_prefix()
+ components <- c(root, renv, prefix, ...)
+ paste(components, collapse = "/")
+ }
+
+ renv_bootstrap_project_type <- function(path) {
+
+ descpath <- file.path(path, "DESCRIPTION")
+ if (!file.exists(descpath))
+ return("unknown")
+
+ desc <- tryCatch(
+ read.dcf(descpath, all = TRUE),
+ error = identity
+ )
+
+ if (inherits(desc, "error"))
+ return("unknown")
+
+ type <- desc$Type
+ if (!is.null(type))
+ return(tolower(type))
+
+ package <- desc$Package
+ if (!is.null(package))
+ return("package")
+
+ "unknown"
+
+ }
+
+ renv_bootstrap_user_dir <- function() {
+ dir <- renv_bootstrap_user_dir_impl()
+ path.expand(chartr("\\", "/", dir))
+ }
+
+ renv_bootstrap_user_dir_impl <- function() {
+
+ # use local override if set
+ override <- getOption("renv.userdir.override")
+ if (!is.null(override))
+ return(override)
+
+ # use R_user_dir if available
+ tools <- asNamespace("tools")
+ if (is.function(tools$R_user_dir))
+ return(tools$R_user_dir("renv", "cache"))
+
+ # try using our own backfill for older versions of R
+ envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME")
+ for (envvar in envvars) {
+ root <- Sys.getenv(envvar, unset = NA)
+ if (!is.na(root))
+ return(file.path(root, "R/renv"))
+ }
+
+ # use platform-specific default fallbacks
+ if (Sys.info()[["sysname"]] == "Windows")
+ file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv")
+ else if (Sys.info()[["sysname"]] == "Darwin")
+ "~/Library/Caches/org.R-project.R/R/renv"
+ else
+ "~/.cache/R/renv"
+
+ }
+
+
+ renv_json_read <- function(file = NULL, text = NULL) {
+
+ text <- paste(text %||% read(file), collapse = "\n")
+
+ # find strings in the JSON
+ pattern <- '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+ locs <- gregexpr(pattern, text, perl = TRUE)[[1]]
+
+ # if any are found, replace them with placeholders
+ replaced <- text
+ strings <- character()
+ replacements <- character()
+
+ if (!identical(c(locs), -1L)) {
+
+ # get the string values
+ starts <- locs
+ ends <- locs + attr(locs, "match.length") - 1L
+ strings <- substring(text, starts, ends)
+
+ # only keep those requiring escaping
+ strings <- grep("[[\\]{}:]", strings, perl = TRUE, value = TRUE)
+
+ # compute replacements
+ replacements <- sprintf('"\032%i\032"', seq_along(strings))
+
+ # replace the strings
+ mapply(function(string, replacement) {
+ replaced <<- sub(string, replacement, replaced, fixed = TRUE)
+ }, strings, replacements)
+
+ }
+
+ # transform the JSON into something the R parser understands
+ transformed <- replaced
+ transformed <- gsub("[[{]", "list(", transformed)
+ transformed <- gsub("[]}]", ")", transformed)
+ transformed <- gsub(":", "=", transformed, fixed = TRUE)
+ text <- paste(transformed, collapse = "\n")
+
+ # parse it
+ json <- parse(text = text, keep.source = FALSE, srcfile = NULL)[[1L]]
+
+ # construct map between source strings, replaced strings
+ map <- as.character(parse(text = strings))
+ names(map) <- as.character(parse(text = replacements))
+
+ # convert to list
+ map <- as.list(map)
+
+ # remap strings in object
+ remapped <- renv_json_remap(json, map)
+
+ # evaluate
+ eval(remapped, envir = baseenv())
+
+ }
+
+ renv_json_remap <- function(json, map) {
+
+ # fix names
+ if (!is.null(names(json))) {
+ lhs <- match(names(json), names(map), nomatch = 0L)
+ rhs <- match(names(map), names(json), nomatch = 0L)
+ names(json)[rhs] <- map[lhs]
+ }
+
+ # fix values
+ if (is.character(json))
+ return(map[[json]] %||% json)
+
+ # handle true, false, null
+ if (is.name(json)) {
+ text <- as.character(json)
+ if (text == "true")
+ return(TRUE)
+ else if (text == "false")
+ return(FALSE)
+ else if (text == "null")
+ return(NULL)
+ }
+
+ # recurse
+ if (is.recursive(json)) {
+ for (i in seq_along(json)) {
+ json[i] <- list(renv_json_remap(json[[i]], map))
+ }
+ }
+
+ json
+
+ }
+
+ # load the renv profile, if any
+ renv_bootstrap_profile_load(project)
+
+ # construct path to library root
+ root <- renv_bootstrap_library_root(project)
+
+ # construct library prefix for platform
+ prefix <- renv_bootstrap_platform_prefix()
+
+ # construct full libpath
+ libpath <- file.path(root, prefix)
+
+ # attempt to load
+ if (renv_bootstrap_load(project, libpath, version))
+ return(TRUE)
+
+ # load failed; inform user we're about to bootstrap
+ prefix <- paste("# Bootstrapping renv", version)
+ postfix <- paste(rep.int("-", 77L - nchar(prefix)), collapse = "")
+ header <- paste(prefix, postfix)
+ message(header)
+
+ # perform bootstrap
+ bootstrap(version, libpath)
+
+ # exit early if we're just testing bootstrap
+ if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA)))
+ return(TRUE)
+
+ # try again to load
+ if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) {
+ message("* Successfully installed and loaded renv ", version, ".")
+ return(renv::load())
+ }
+
+ # failed to download or load renv; warn the user
+ msg <- c(
+ "Failed to find an renv installation: the project will not be loaded.",
+ "Use `renv::activate()` to re-initialize the project."
+ )
+
+ warning(paste(msg, collapse = "\n"), call. = FALSE)
+
+})
diff --git a/renv/settings.dcf b/renv/settings.dcf
new file mode 100644
index 0000000..169d82f
--- /dev/null
+++ b/renv/settings.dcf
@@ -0,0 +1,10 @@
+bioconductor.version:
+external.libraries:
+ignored.packages:
+package.dependency.fields: Imports, Depends, LinkingTo
+r.version:
+snapshot.type: implicit
+use.cache: TRUE
+vcs.ignore.cellar: TRUE
+vcs.ignore.library: TRUE
+vcs.ignore.local: TRUE
diff --git a/template.Rmd b/template.Rmd
index 801d4b4..cc52b0d 100644
--- a/template.Rmd
+++ b/template.Rmd
@@ -14,4 +14,21 @@ editor_options:
chunk_output_type: console
---
-# Intro
\ No newline at end of file
+# Intro
+
+This is the Flipside Crypto RMarkdown template. It includes an renv lockfile with shroomDK.
+Please ensure renv is installed on your machine and use the provided chunk (click Show Code) to begin.
+
+To use this template:
+
+1. Clone this repo into a new repo
+2. Rename the R Project
+3. Rename the template Rmd file
+4. Restore the r environment
+5. Push your new repo with new file names.
+6. Begin working! You can edit the header, footer, and styles.css file as needed, some defaults are provided. Use Knit to HTML to view the effects of these defaults.
+
+```{r}
+renv::restore()
+library(shroomDK)
+```
\ No newline at end of file