From 8daf560ef2b129e4a1e385e983b7d6362103d9af Mon Sep 17 00:00:00 2001 From: Emma Rand Date: Fri, 21 Jul 2023 16:52:04 +0100 Subject: [PATCH] + infrastructure --- .Rprofile | 1 + CITATION.cff | 11 + _quarto.yml | 144 ++- core/core.qmd | 19 + core/week-1/overview.qmd | 33 + core/week-1/study_after_workshop.qmd | 25 + core/week-1/study_before_workshop.qmd | 6 + core/week-1/workshop.qmd | 76 ++ index.qmd | 37 +- omics/omics.qmd | 19 + references.bib | 143 +++ renv.lock | 23 + renv/.gitignore | 7 + renv/activate.R | 1181 +++++++++++++++++++++++++ renv/settings.json | 19 + 15 files changed, 1733 insertions(+), 11 deletions(-) create mode 100644 .Rprofile create mode 100644 CITATION.cff create mode 100644 core/core.qmd create mode 100644 core/week-1/overview.qmd create mode 100644 core/week-1/study_after_workshop.qmd create mode 100644 core/week-1/study_before_workshop.qmd create mode 100644 core/week-1/workshop.qmd create mode 100644 omics/omics.qmd create mode 100644 references.bib create mode 100644 renv.lock create mode 100644 renv/.gitignore create mode 100644 renv/activate.R create mode 100644 renv/settings.json 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/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..34125e6 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,11 @@ +cff-version: 1.2.0 +message: "Please cite these materials as below." +authors: +- family-names: "Rand" + given-names: "Emma" + orcid: "https://orcid.org/0000-0002-1358-8275" +title: "Data Analysis for Group Project" +version: 0.1 +doi: +date-released: 2023-08-01 +url: "https://3mmarand.github.io/BIO00088H-data/" diff --git a/_quarto.yml b/_quarto.yml index 08015c7..71cc456 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -1,19 +1,147 @@ project: type: website + output-dir: _site website: - title: "BIO00088H-data" + title: "Data Analysis for Group Project" + page-footer: + left: '`r cffr::cff_to_bibtex("CITATION.cff")`' + right: + - icon: twitter + href: https://twitter.com/er_13 + aria-label: Twitter + - icon: github + href: https://github.com/3mmaRand/BIO00088H-data + aria-label: BIO00088H-data GitHub navbar: + background: light + twitter-card: true + site-url: https://3mmarand.github.io/BIO00088H-data/ + repo-url: https://github.com/3mmaRand/BIO00088H-data + issue-url: https://github.com/3mmaRand/BIO00088H-data/issues/new/choose + repo-actions: [edit, issue] + page-navigation: true + search: true left: - - href: index.qmd - text: Home - - about.qmd + - text: "Welcome!" + file: index.qmd + - text: "Core" + file: core/core.qmd + - text: "Omics" + file: omics/omics.qmd + tools: + - icon: twitter + href: https://twitter.com/er_13 + text: Emma's Twitter + - icon: github + href: https://github.com/3mmaRand/BIO00088H-data + text: BIO00088H-data GitHub + + sidebar: + - title: "Core" + style: "floating" + contents: + - href: core/core.qmd + - text: --- + - text: --- + - section: "Week 1: xxx" + contents: + - href: core/week-1/overview.qmd + text: About + - href: core/week-1/study_before_workshop.qmd + text: Prepare! + - href: core/week-1/workshop.qmd + text: Workshop + - href: core/week-1/study_after_workshop.qmd + text: Consolidate! + - text: --- + - section: "Week 2: xxx" + contents: + - href: core/week-2/overview.qmd + text: About + - href: core/week-2/study_before_workshop.qmd + text: Prepare! + - href: core/week-2/workshop.qmd + text: Workshop + - href: core/week-2/study_after_workshop.qmd + text: Consolidate! + - text: --- + - section: "Week 6: Quarto" + contents: + - href: core/week-6/overview.qmd + text: About + - href: core/week-6/study_before_workshop.qmd + text: Prepare! + - href: core/week-6/workshop.qmd + text: Workshop + - href: core/week-6/study_after_workshop.qmd + text: Consolidate! + - title: "Omics" + style: "floating" + contents: + - href: omics/omics.qmd + - text: --- + - text: --- + - section: "Week 3: xx" + contents: + - href: omics/week-3/overview.qmd + text: About + - href: omics/week-3/study_before_workshop.qmd + text: Prepare! + - href: omics/week-3/workshop.qmd + text: Workshop + - href: omics/week-3/study_after_workshop.qmd + text: Consolidate! + - text: --- + - section: "Week 4: xxx" + contents: + - href: omics/week-4/overview.qmd + text: About + - href: omics/week-4/study_before_workshop.qmd + text: Prepare! + - href: omics/week-4/workshop.qmd + text: Workshop + - href: omics/week-4/study_after_workshop.qmd + text: Consolidate! + - text: --- + - section: "Week 5: xxx" + contents: libray/week-5/overview.qmd + text: About + - href: omics/week-5/study_before_workshop.qmd + text: Prepare! + - href: omics/week-5/workshop.qmd + text: Workshop + - href: omics/week-5/study_after_workshop.qmd + text: Consolidate! +execute: + echo: true + warning: false + output: true + error: true + collapse: true + format: html: - theme: cosmo - css: styles.css - toc: true + link-external-newwindow: true + link-external-filter: '^(?:http:|https:)\/\/3mmarand\.github\.io\/BIO00088H-data' + theme: + light: [cosmo, custom.scss] + code-copy: true + code-link: true + code-overflow: wrap + code-line-numbers: false + grid: + sidebar-width: 250px + body-width: 900px + margin-width: 300px + + author-meta: Emma Rand + +bibliography: references.bib + + +editor: source + -editor: visual diff --git a/core/core.qmd b/core/core.qmd new file mode 100644 index 0000000..45d4132 --- /dev/null +++ b/core/core.qmd @@ -0,0 +1,19 @@ +--- +title: "Core Data Analysis for Group Project" +toc: true +toc-location: right +--- + +# Content + +## Core 1 + +erwtERTERTG + +## Core 2 + +rgetgretger + +## Core 3: Quarto + +fgzzdfghdfhg diff --git a/core/week-1/overview.qmd b/core/week-1/overview.qmd new file mode 100644 index 0000000..f2b26bc --- /dev/null +++ b/core/week-1/overview.qmd @@ -0,0 +1,33 @@ +--- +title: "Overview" +subtitle: "Core 1" +--- + +xxxxx + +### Learning objectives + +- dd +- dd. +- dd +- d + +### Instructions + +1. [Prepare](study_before_workshop.qmd) + + i. 📖 Read ddd + +2. [Workshop](workshop.qmd) + + i. 💻 dd. + + ii. 💻 ddd + + iii. 💻 ddd + +3. [Consolidate](study_after_workshop.qmd) + + i. 💻 dd + + ii. 💻 dd diff --git a/core/week-1/study_after_workshop.qmd b/core/week-1/study_after_workshop.qmd new file mode 100644 index 0000000..2591f8c --- /dev/null +++ b/core/week-1/study_after_workshop.qmd @@ -0,0 +1,25 @@ +--- +title: "Independent Study to consolidate this week" +subtitle: "Core 1" +format: + html: + code-fold: true + code-summary: "Answer - don't look until you have tried!" +--- + +# Set up + +If you have just opened RStudio you will want to load the packages and import the data. + +```{r} +#| code-fold: false +library(tidyverse) +library(readxl) +``` + +1. 💻 xx. + +```{r} + + +``` diff --git a/core/week-1/study_before_workshop.qmd b/core/week-1/study_before_workshop.qmd new file mode 100644 index 0000000..952b776 --- /dev/null +++ b/core/week-1/study_before_workshop.qmd @@ -0,0 +1,6 @@ +--- +title: "Independent Study to prepare for workshop" +subtitle: "Core 1" +--- + +1. 📖 Read xxxx diff --git a/core/week-1/workshop.qmd b/core/week-1/workshop.qmd new file mode 100644 index 0000000..4123230 --- /dev/null +++ b/core/week-1/workshop.qmd @@ -0,0 +1,76 @@ +--- +title: "Workshop" +subtitle: "xxx" +toc: true +toc-location: right +--- + +```{r} +#| include: false +library(tidyverse) +``` + +# Introduction + + +## Session overview + +In this workshop you will learn to summarise and plot datasets with more than one variable and how to write figures to files. You will also get more practice with working directories, importing data, formatting figures and the pipe. + +## Philosophy + +Workshops are not a test. It is expected that you often don't know how to start, make a lot of mistakes and need help. It is expected that you are familiar with independent study content before the workshop. However, you need not remember or understand every detail as the workshop should build and consolidate your understanding. Tips + +- don't worry about making mistakes +- don't let what you can not do interfere with what you can do +- discussing code with your neighbours will help +- look things up in the independent study material +- look things up in your own code from earlier workshops +- there are no stupid questions + +::: callout-note +## Key + +These four symbols are used at the beginning of each instruction so you know where to carry out the instruction. + +![](images/do_on_your_computer.png) Something you need to do on your computer. It may be opening programs or documents or locating a file. + +![](images/do_in_R.png) Something you should do in RStudio. It will often be typing a command or using the menus but might also be creating folders, locating or moving files. + +![](images/do_on_internet.png) Something you should do in your browser on the internet. It may be searching for information, going to the VLE or downloading a file. + +![](images/answer.png) A question for you to think about and answer. Record your answers in your script for future reference. +::: + +# Getting started + +Start RStudio make an RStudio project for this workshop. + +Make a new folder called `data-raw`. + +Make a new script then save it to carry out the rest of the work. + +Add code to load the **`tidyverse`** package [@tidyverse] + +# Exercises + + +You're finished! + +# 🥳 Well Done! 🎉 + + + +# Independent study following the workshop + +[Consolidate](study_after_workshop.qmd) + +# The Code file + +These contain all the code needed in the workshop even where it is not visible on the webpage. + +The [workshop.qmd](workshop.qmd) file is the file I use to compile the practical. Qmd stands for Quarto markdown. It allows code and ordinary text to be interleaved to produce well-formatted reports including webpages. Right-click on the link and choose Save-As to download. You will be able to open the Qmd file in RStudio. Alternatively, [View in Browser](https://github.com/3mmaRand/). Coding and thinking answers are marked with `#---CODING ANSWER---` and `#---THINKING ANSWER---` + +Pages made with R [@R-core], Quarto [@allaire2022], `knitr` [@knitr], `kableExtra` [@kableExtra] + +# References diff --git a/index.qmd b/index.qmd index 699dfee..72b1c9d 100644 --- a/index.qmd +++ b/index.qmd @@ -1,7 +1,38 @@ --- -title: "BIO00088H-data" +title: "Data Analysis for Group Project" +toc: true +toc-location: right --- -This is a Quarto website. +# Overview + +blah + +## Module Learning Objectives + +The BIO00088H Module Learning outcomes that relate this content are + +- .. + +- .. + + +Each week has: + +- An overview on the "About" page which gives the Learning Objectives, a topic summary and the instructions for the week. You should read this first. + +- Some independent study on the "Prepare!" page to prepare you for the workshop. It is designed to take about 30-45 mins on average. You will most likely learn best if you can find people to study with. + +- A two-hour workshop. Talking to other people in the workshop about the exercises and working together will really help you understand more. There will be plenty of help from me and my demonstrators. + +- Some independent study on the "Consolidate!" page to give you more practice. The exercises are usually similar to those in the workshop but with less guidance. It is designed to take about 30-45 mins on average but may be quicker if you understood the workshop very well or slower if you need to revisit the workshop. + + +## What is this site for? + +All material is on the VLE so why is this site useful? Well, perhaps more than any other material, you will want to refer back when applying your skills and this site collects everything together in a searchable way. The search icon is on the top right. + +Resources. + +R4 BABS -To learn more about Quarto websites visit . diff --git a/omics/omics.qmd b/omics/omics.qmd new file mode 100644 index 0000000..86afe3f --- /dev/null +++ b/omics/omics.qmd @@ -0,0 +1,19 @@ +--- +title: "Omics Data Analysis for Group Project" +toc: true +toc-location: right +--- + +# Content + +## Omics 1 + +erwtERTERTG + +## Omics 2 + +rgetgretger + +## Omics 3 + +fgzzdfghdfhg diff --git a/references.bib b/references.bib new file mode 100644 index 0000000..f22aac2 --- /dev/null +++ b/references.bib @@ -0,0 +1,143 @@ + +@article{ggplot2, + title = {ggplot2: Elegant Graphics for Data Analysis}, + author = {Wickham, Hadley}, + year = {2016}, + date = {2016}, + url = {https://ggplot2.tidyverse.org} +} + +@article{tidyverse, + title = {Welcome to the {\textbraceleft}tidyverse{\textbraceright}}, + author = {Wickham, Hadley and Averick, Mara and Bryan, Jennifer and Chang, Winston and McGowan, {Lucy D'Agostino} and {François}, Romain and Grolemund, Garrett and Hayes, Alex and Henry, Lionel and Hester, Jim and Kuhn, Max and Pedersen, Thomas Lin and Miller, Evan and Bache, Stephan Milton and {Müller}, Kirill and Ooms, Jeroen and Robinson, David and Seidel, Dana Paige and Spinu, Vitalie and Takahashi, Kohske and Vaughan, Davis and Wilke, Claus and Woo, Kara and Yutani, Hiroaki}, + year = {2019}, + date = {2019}, + pages = {1686}, + volume = {4}, + doi = {10.21105/joss.01686} +} + +@book{allaire2022, + title = {Quarto}, + author = {Allaire, J.J. and Teague, Charles and Scheidegger, Carlos and Xie, Yihui and Dervieux, Christophe}, + year = {2022}, + month = {01}, + date = {2022-01}, + doi = {10.5281/zenodo.5960048}, + url = {https://github.com/quarto-dev/quarto-cli}, + note = {DOI: 10.5281/zenodo.5960048} +} + +@misc{1.membershipofworkinggroup2.termsofreference, + title = {Report of the DORA working group}, + author = {1. Membership of Working Group 2. Terms of reference, }, + url = {https://www.imperial.ac.uk/media/imperial-college/research-and-innovation/public/DORA-working-group-recommendations-2017.pdf} +} + +@ARTICLE{Wickham2014-nl, + title = "Tidy Data", + author = "Wickham, Hadley", + abstract = "A huge amount of effort is spent cleaning data to get it ready + for analysis, but there has been little research on how to make + data cleaning as easy and effective as possible. This paper + tackles a small, but important, component of data cleaning: data + tidying. Tidy datasets are easy to manipulate, model and + visualize, and have a specific structure: each variable is a + column, each observation is a row, and each type of observational + unit is a table. This framework makes it easy to tidy messy + datasets because only a small set of tools are needed to deal + with a wide range of un-tidy datasets. This structure also makes + it easier to develop tidy tools for data analysis, tools that + both input and output tidy datasets. The advantages of a + consistent data structure and matching tools are demonstrated + with a case study free from mundane data manipulation chores.", + journal = "Journal of Statistical Software, Articles", + volume = 59, + number = 10, + pages = "1--23", + year = 2014, + url = "https://vita.had.co.nz/papers/tidy-data.pdf", +} +@article{knitr, + title = {knitr: A General-Purpose Package for Dynamic Report Generation in R}, + author = {Xie, Yihui}, + year = {2022}, + date = {2022}, + url = {https://yihui.org/knitr/} +} + +@article{kableExtra, + title = {kableExtra: Construct Complex Table with 'kable' and Pipe Syntax}, + author = {Zhu, Hao}, + year = {2021}, + date = {2021}, + url = {https://CRAN.R-project.org/package=kableExtra} +} + +@book{rand2023, + title = {Data Analysis in R for Becoming a Bioscientist}, + author = {Rand, Emma}, + year = {2023}, + month = {05}, + date = {2023-05}, + url = {https://3mmarand.github.io/R4BABS/} +} + +@article{wickham2014, + title = {Tidy Data}, + author = {Wickham, Hadley}, + year = {2014}, + month = {09}, + date = {2014-09-12}, + journal = {Journal of Statistical Software}, + pages = {1--23}, + volume = {59}, + doi = {10.18637/jss.v059.i10}, + url = {https://doi.org/10.18637/jss.v059.i10}, + langid = {en} +} + +@article{readxl, + title = {readxl: Read Excel Files}, + author = {Wickham, Hadley and Bryan, Jennifer}, + year = {2023}, + date = {2023}, + url = {https://CRAN.R-project.org/package=readxl} +} + +@Manual{R-core, + title = {R: A Language and Environment for Statistical Computing}, + author = {{R Core Team}}, + organization = {R Foundation for Statistical Computing}, + address = {Vienna, Austria}, + year = {2023}, + url = {https://www.R-project.org/}, + } + +@misc{allison_horst, + title = {Data Science Illustrations}, + author = {Allison Horst}, + year = {2023}, + url = {https://allisonhorst.com/allison-horst}, + } +@article{tukey1949, + title = {Comparing Individual Means in the Analysis of Variance}, + author = {Tukey, John W.}, + year = {1949}, + date = {1949}, + journal = {Biometrics}, + pages = {99--114}, + volume = {5}, + number = {2}, + doi = {10.2307/3001913}, + url = {https://www.jstor.org/stable/3001913}, + note = {Publisher: [Wiley, International Biometric Society]} +} + +@Manual{emmeans, + title = {emmeans: Estimated Marginal Means, aka Least-Squares Means}, + author = {Russell V. Lenth}, + year = {2023}, + note = {R package version 1.8.7}, + url = {https://CRAN.R-project.org/package=emmeans}, +} \ No newline at end of file diff --git a/renv.lock b/renv.lock new file mode 100644 index 0000000..d69ca3b --- /dev/null +++ b/renv.lock @@ -0,0 +1,23 @@ +{ + "R": { + "Version": "4.3.1", + "Repositories": [ + { + "Name": "CRAN", + "URL": "https://packagemanager.posit.co/cran/latest" + } + ] + }, + "Packages": { + "renv": { + "Package": "renv", + "Version": "1.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "utils" + ], + "Hash": "c321cd99d56443dbffd1c9e673c0c1a2" + } + } +} diff --git a/renv/.gitignore b/renv/.gitignore new file mode 100644 index 0000000..0ec0cbb --- /dev/null +++ b/renv/.gitignore @@ -0,0 +1,7 @@ +library/ +local/ +cellar/ +lock/ +python/ +sandbox/ +staging/ diff --git a/renv/activate.R b/renv/activate.R new file mode 100644 index 0000000..cc742fc --- /dev/null +++ b/renv/activate.R @@ -0,0 +1,1181 @@ + +local({ + + # the requested version of renv + version <- "1.0.0" + attr(version, "sha") <- NULL + + # 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.null(x)) y else x + } + + catf <- function(fmt, ..., appendLF = TRUE) { + + quiet <- getOption("renv.bootstrap.quiet", default = FALSE) + if (quiet) + return(invisible()) + + msg <- sprintf(fmt, ...) + cat(msg, file = stdout(), sep = if (appendLF) "\n" else "") + + invisible(msg) + + } + + header <- function(label, + ..., + prefix = "#", + suffix = "-", + n = min(getOption("width"), 78)) + { + label <- sprintf(label, ...) + n <- max(n - nchar(label) - nchar(prefix) - 2L, 8L) + if (n <= 0) + return(paste(prefix, label)) + + tail <- paste(rep.int(suffix, n), collapse = "") + paste0(prefix, " ", label, " ", tail) + + } + + startswith <- function(string, prefix) { + substring(string, 1, nchar(prefix)) == prefix + } + + bootstrap <- function(version, library) { + + friendly <- renv_bootstrap_version_friendly(version) + section <- header(sprintf("Bootstrapping renv %s", friendly)) + catf(section) + + # attempt to download renv + catf("- Downloading renv ... ", appendLF = FALSE) + withCallingHandlers( + tarball <- renv_bootstrap_download(version), + error = function(err) { + catf("FAILED") + stop("failed to download:\n", conditionMessage(err)) + } + ) + catf("OK") + on.exit(unlink(tarball), add = TRUE) + + # now attempt to install + catf("- Installing renv ... ", appendLF = FALSE) + withCallingHandlers( + status <- renv_bootstrap_install(version, tarball, library), + error = function(err) { + catf("FAILED") + stop("failed to install:\n", conditionMessage(err)) + } + ) + catf("OK") + + # add empty line to break up bootstrapping from normal output + catf("") + + return(invisible()) + } + + renv_bootstrap_tests_running <- function() { + getOption("renv.tests.running", default = FALSE) + } + + renv_bootstrap_repos <- function() { + + # get CRAN repository + cran <- getOption("renv.repos.cran", "https://cloud.r-project.org") + + # check for repos override + repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA) + if (!is.na(repos)) { + + # check for RSPM; if set, use a fallback repository for renv + rspm <- Sys.getenv("RSPM", unset = NA) + if (identical(rspm, repos)) + repos <- c(RSPM = rspm, CRAN = cran) + + return(repos) + + } + + # check for lockfile repositories + repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity) + if (!inherits(repos, "error") && length(repos)) + return(repos) + + # retrieve current repos + repos <- getOption("repos") + + # ensure @CRAN@ entries are resolved + repos[repos == "@CRAN@"] <- cran + + # 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) { + + sha <- attr(version, "sha", exact = TRUE) + + methods <- if (!is.null(sha)) { + + # attempting to bootstrap a development version of renv + c( + function() renv_bootstrap_download_tarball(sha), + function() renv_bootstrap_download_github(sha) + ) + + } else { + + # attempting to bootstrap a release version of renv + c( + function() renv_bootstrap_download_tarball(version), + function() renv_bootstrap_download_cran_latest(version), + function() renv_bootstrap_download_cran_archive(version) + ) + + } + + for (method in methods) { + path <- tryCatch(method(), error = identity) + if (is.character(path) && file.exists(path)) + return(path) + } + + stop("All download methods failed") + + } + + 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" + + args <- list( + url = url, + destfile = destfile, + mode = mode, + quiet = TRUE + ) + + if ("headers" %in% names(formals(utils::download.file))) + args$headers <- renv_bootstrap_download_custom_headers(url) + + do.call(utils::download.file, args) + + } + + renv_bootstrap_download_custom_headers <- function(url) { + + headers <- getOption("renv.download.headers") + if (is.null(headers)) + return(character()) + + if (!is.function(headers)) + stopf("'renv.download.headers' is not a function") + + headers <- headers(url) + if (length(headers) == 0L) + return(character()) + + if (is.list(headers)) + headers <- unlist(headers, recursive = FALSE, use.names = TRUE) + + ok <- + is.character(headers) && + is.character(names(headers)) && + all(nzchar(names(headers))) + + if (!ok) + stop("invocation of 'renv.download.headers' did not return a named character vector") + + headers + + } + + renv_bootstrap_download_cran_latest <- function(version) { + + spec <- renv_bootstrap_download_cran_latest_find(version) + type <- spec$type + repos <- spec$repos + + baseurl <- utils::contrib.url(repos = repos, type = type) + ext <- if (identical(type, "source")) + ".tar.gz" + else if (Sys.info()[["sysname"]] == "Windows") + ".zip" + else + ".tgz" + name <- sprintf("renv_%s%s", version, ext) + url <- paste(baseurl, name, sep = "/") + + destfile <- file.path(tempdir(), name) + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (inherits(status, "condition")) + return(FALSE) + + # report success and return + destfile + + } + + 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) + + for (url in urls) { + + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (identical(status, 0L)) + return(destfile) + + } + + 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 + if (dir.exists(tarball)) { + 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() + + } + + catf("- Using local tarball '%s'.", tarball) + 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) + } + + 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)) + return(FALSE) + + renv_bootstrap_download_augment(destfile) + + return(destfile) + + } + + # Add Sha to DESCRIPTION. This is stop gap until #890, after which we + # can use renv::install() to fully capture metadata. + renv_bootstrap_download_augment <- function(destfile) { + sha <- renv_bootstrap_git_extract_sha1_tar(destfile) + if (is.null(sha)) { + return() + } + + # Untar + tempdir <- tempfile("renv-github-") + on.exit(unlink(tempdir, recursive = TRUE), add = TRUE) + untar(destfile, exdir = tempdir) + pkgdir <- dir(tempdir, full.names = TRUE)[[1]] + + # Modify description + desc_path <- file.path(pkgdir, "DESCRIPTION") + desc_lines <- readLines(desc_path) + remotes_fields <- c( + "RemoteType: github", + "RemoteHost: api.github.com", + "RemoteRepo: renv", + "RemoteUsername: rstudio", + "RemotePkgRef: rstudio/renv", + paste("RemoteRef: ", sha), + paste("RemoteSha: ", sha) + ) + writeLines(c(desc_lines[desc_lines != ""], remotes_fields), con = desc_path) + + # Re-tar + local({ + old <- setwd(tempdir) + on.exit(setwd(old), add = TRUE) + + tar(destfile, compression = "gzip") + }) + invisible() + } + + # Extract the commit hash from a git archive. Git archives include the SHA1 + # hash as the comment field of the tarball pax extended header + # (see https://www.kernel.org/pub/software/scm/git/docs/git-archive.html) + # For GitHub archives this should be the first header after the default one + # (512 byte) header. + renv_bootstrap_git_extract_sha1_tar <- function(bundle) { + + # open the bundle for reading + # We use gzcon for everything because (from ?gzcon) + # > Reading from a connection which does not supply a ‘gzip’ magic + # > header is equivalent to reading from the original connection + conn <- gzcon(file(bundle, open = "rb", raw = TRUE)) + on.exit(close(conn)) + + # The default pax header is 512 bytes long and the first pax extended header + # with the comment should be 51 bytes long + # `52 comment=` (11 chars) + 40 byte SHA1 hash + len <- 0x200 + 0x33 + res <- rawToChar(readBin(conn, "raw", n = len)[0x201:len]) + + if (grepl("^52 comment=", res)) { + sub("52 comment=", "", res) + } else { + NULL + } + } + + renv_bootstrap_install <- function(version, tarball, library) { + + # attempt to install it into project library + dir.create(library, showWarnings = FALSE, recursive = TRUE) + output <- renv_bootstrap_install_impl(library, tarball) + + # check for successful install + status <- attr(output, "status") + if (is.null(status) || identical(status, 0L)) + return(status) + + # an error occurred; report it + header <- "installation of renv failed" + lines <- paste(rep.int("=", nchar(header)), collapse = "") + text <- paste(c(header, lines, output), collapse = "\n") + stop(text) + + } + + renv_bootstrap_install_impl <- function(library, tarball) { + + # 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)) + ) + + system2(R, args, stdout = TRUE, stderr = TRUE) + + } + + 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, description = NULL) { + + # resolve description file + description <- description %||% { + path <- getNamespaceInfo("renv", "path") + packageDescription("renv", lib.loc = dirname(path)) + } + + # check whether requested version 'version' matches loaded version of renv + sha <- attr(version, "sha", exact = TRUE) + valid <- if (!is.null(sha)) + renv_bootstrap_validate_version_dev(sha, description) + else + renv_bootstrap_validate_version_release(version, description) + + if (valid) + return(TRUE) + + # the loaded version of renv doesn't match the requested version; + # give the user instructions on how to proceed + remote <- if (!is.null(description[["RemoteSha"]])) { + paste("rstudio/renv", description[["RemoteSha"]], sep = "@") + } else { + paste("renv", description[["Version"]], sep = "@") + } + + # display both loaded version + sha if available + friendly <- renv_bootstrap_version_friendly( + version = description[["Version"]], + sha = description[["RemoteSha"]] + ) + + 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" + ) + catf(fmt, friendly, renv_bootstrap_version_friendly(version), remote) + + FALSE + + } + + renv_bootstrap_validate_version_dev <- function(version, description) { + expected <- description[["RemoteSha"]] + is.character(expected) && startswith(expected, version) + } + + renv_bootstrap_validate_version_release <- function(version, description) { + expected <- description[["Version"]] + is.character(expected) && identical(expected, version) + } + + 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) + + # execute renv load hooks, if any + hooks <- getHook("renv::autoload") + for (hook in hooks) + if (is.function(hook)) + tryCatch(hook(), error = warning) + + # 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, project = project) + 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_bootstrap_version_friendly <- function(version, sha = NULL) { + sha <- sha %||% attr(version, "sha", exact = TRUE) + parts <- c(version, sprintf("[sha: %s]", substring(sha, 1L, 7L))) + paste(parts, collapse = " ") + } + + renv_bootstrap_run <- function(version, libpath) { + + # 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)) { + return(renv::load(project = getwd())) + } + + # 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) + + } + + + renv_bootstrap_in_rstudio <- function() { + commandArgs()[[1]] == "RStudio" + } + + renv_json_read <- function(file = NULL, text = NULL) { + + jlerr <- NULL + + # if jsonlite is loaded, use that instead + if ("jsonlite" %in% loadedNamespaces()) { + + json <- catch(renv_json_read_jsonlite(file, text)) + if (!inherits(json, "error")) + return(json) + + jlerr <- json + + } + + # otherwise, fall back to the default JSON reader + json <- catch(renv_json_read_default(file, text)) + if (!inherits(json, "error")) + return(json) + + # report an error + if (!is.null(jlerr)) + stop(jlerr) + else + stop(json) + + } + + renv_json_read_jsonlite <- function(file = NULL, text = NULL) { + text <- paste(text %||% read(file), collapse = "\n") + jsonlite::fromJSON(txt = text, simplifyVector = FALSE) + } + + renv_json_read_default <- function(file = NULL, text = NULL) { + + # find strings in the JSON + text <- paste(text %||% read(file), collapse = "\n") + 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("{}", "`names<-`(list(), character())", transformed, fixed = TRUE) + transformed <- gsub("[[{]", "list(", transformed, perl = TRUE) + transformed <- gsub("[]}]", ")", transformed, perl = TRUE) + 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) + + if (renv_bootstrap_in_rstudio()) { + setHook("rstudio.sessionInit", function(...) { + renv_bootstrap_run(version, libpath) + + # Work around buglet in RStudio if hook uses readline + tryCatch( + { + tools <- as.environment("tools:rstudio") + tools$.rs.api.sendToConsole("", echo = FALSE, focus = FALSE) + }, + error = function(cnd) {} + ) + }) + } else { + renv_bootstrap_run(version, libpath) + } + + invisible() + +}) diff --git a/renv/settings.json b/renv/settings.json new file mode 100644 index 0000000..ffdbb32 --- /dev/null +++ b/renv/settings.json @@ -0,0 +1,19 @@ +{ + "bioconductor.version": null, + "external.libraries": [], + "ignored.packages": [], + "package.dependency.fields": [ + "Imports", + "Depends", + "LinkingTo" + ], + "ppm.enabled": null, + "ppm.ignored.urls": [], + "r.version": null, + "snapshot.type": "implicit", + "use.cache": true, + "vcs.ignore.cellar": true, + "vcs.ignore.library": true, + "vcs.ignore.local": true, + "vcs.manage.ignores": true +}