From fb8c7f137e7982517fbccb65f0e8c37aff7597b7 Mon Sep 17 00:00:00 2001 From: Jenna Reps Date: Wed, 5 Oct 2022 12:21:41 -0400 Subject: [PATCH] initial version initial version --- .gitignore | 4 + Main.R | 137 +++++ MetaData.json | 6 + NEWS.md | 4 + PatientLevelPredictionModule.Rproj | 18 + README.md | 35 ++ SettingsFunctions.R | 18 + renv.lock | 681 +++++++++++++++++++++ renv/activate.R | 942 +++++++++++++++++++++++++++++ 9 files changed, 1845 insertions(+) create mode 100644 .gitignore create mode 100644 Main.R create mode 100644 MetaData.json create mode 100644 NEWS.md create mode 100644 PatientLevelPredictionModule.Rproj create mode 100644 README.md create mode 100644 SettingsFunctions.R create mode 100644 renv.lock create mode 100644 renv/activate.R diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5b6a065 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.Rproj.user +.Rhistory +.RData +.Ruserdata diff --git a/Main.R b/Main.R new file mode 100644 index 0000000..73a37a7 --- /dev/null +++ b/Main.R @@ -0,0 +1,137 @@ +# Copyright 2022 Observational Health Data Sciences and Informatics +# +# This file is part of CohortGeneratorModule +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Module methods ------------------------- +getModuleInfo <- function() { + checkmate::assert_file_exists("MetaData.json") + return(ParallelLogger::loadSettingsFromJson("MetaData.json")) +} + +getSharedResourceByClassName <- function(sharedResources, className) { + returnVal <- NULL + for (i in 1:length(sharedResources)) { + if (className %in% class(sharedResources[[i]])) { + returnVal <- sharedResources[[i]] + break + } + } + invisible(returnVal) +} + +createCohortDefinitionSetFromJobContext <- function(sharedResources, settings) { + cohortDefinitions <- list() + if (length(sharedResources) <= 0) { + stop("No shared resources found") + } + cohortDefinitionSharedResource <- getSharedResourceByClassName(sharedResources = sharedResources, + class = "CohortDefinitionSharedResources") + if (is.null(cohortDefinitionSharedResource)) { + stop("Cohort definition shared resource not found!") + } + cohortDefinitions <- cohortDefinitionSharedResource$cohortDefinitions + if (length(cohortDefinitions) <= 0) { + stop("No cohort definitions found") + } + cohortDefinitionSet <- CohortGenerator::createEmptyCohortDefinitionSet() + for (i in 1:length(cohortDefinitions)) { + cohortJson <- cohortDefinitions[[i]]$cohortDefinition + cohortDefinitionSet <- rbind(cohortDefinitionSet, data.frame( + cohortId = as.integer(cohortDefinitions[[i]]$cohortId), + cohortName = cohortDefinitions[[i]]$cohortName, + json = cohortJson, + stringsAsFactors = FALSE + )) + } + return(cohortDefinitionSet) +} + +# Module methods ------------------------- +execute <- function(jobContext) { + rlang::inform("Validating inputs") + inherits(jobContext, 'list') + + if (is.null(jobContext$settings)) { + stop("Analysis settings not found in job context") + } + if (is.null(jobContext$sharedResources)) { + stop("Shared resources not found in job context") + } + if (is.null(jobContext$moduleExecutionSettings)) { + stop("Execution settings not found in job context") + } + + workFolder <- jobContext$moduleExecutionSettings$workSubFolder + resultsFolder <- jobContext$moduleExecutionSettings$resultsSubFolder + + rlang::inform("Executing PLP") + moduleInfo <- getModuleInfo() + + # Creating database details + databaseDetails <- PatientLevelPrediction::createDatabaseDetails( + connectionDetails = jobContext$moduleExecutionSettings$connectionDetails, + cdmDatabaseSchema = jobContext$moduleExecutionSettings$cdmDatabaseSchema, + cohortDatabaseSchema = jobContext$moduleExecutionSettings$workDatabaseSchema, + cdmDatabaseName = jobContext$moduleExecutionSettings$connectionDetailsReference, + cdmDatabaseId = jobContext$moduleExecutionSettings$databaseId, + #tempEmulationSchema = , is there s temp schema specified anywhere? + cohortTable = jobContext$moduleExecutionSettings$cohortTableNames$cohortTable, + outcomeDatabaseSchema = jobContext$moduleExecutionSettings$workDatabaseSchema, + outcomeTable = jobContext$moduleExecutionSettings$cohortTableNames$cohortTable + ) + + # find where cohortDefinitions are as sharedResources is a list + cohortDefinitionSet <- createCohortDefinitionSetFromJobContext( + sharedResources = jobContext$sharedResources, + settings = jobContext$settings + ) + + # run the models + PatientLevelPrediction::runMultiplePlp( + databaseDetails = databaseDetails, + modelDesignList = jobContext$settings, + cohortDefinitions = cohortDefinitionSet, + saveDirectory = workFolder + ) + + # Export the results + rlang::inform("Export data to csv files") + + sqliteConnectionDetails <- DatabaseConnector::createConnectionDetails( + dbms = 'sqlite', + server = file.path(workFolder, "sqlite","databaseFile.sqlite") + ) + + PatientLevelPrediction::extractDatabaseToCsv( + connectionDetails = sqliteConnectionDetails, + databaseSchemaSettings = PatientLevelPrediction::createDatabaseSchemaSettings( + resultSchema = 'main', # sqlite settings + tablePrefix = '', # sqlite settings + targetDialect = 'sqlite', + tempEmulationSchema = NULL + ), + csvFolder = file.path(workFolder, 'results'), + fileAppend = NULL + ) + + # Zip the results + rlang::inform("Zipping csv files") + DatabaseConnector::createZipFile( + zipFile = file.path(resultsFolder, 'results.zip'), + files = file.path(workFolder, 'results') + ) + + +} \ No newline at end of file diff --git a/MetaData.json b/MetaData.json new file mode 100644 index 0000000..8e71eb6 --- /dev/null +++ b/MetaData.json @@ -0,0 +1,6 @@ +{ + "Name": "PatientLevelPredictionModule", + "Version": "0.0.1", + "Dependencies": ["CohortGeneratorModule"], + "TablePrefix": "plp_" +} diff --git a/NEWS.md b/NEWS.md new file mode 100644 index 0000000..480a05d --- /dev/null +++ b/NEWS.md @@ -0,0 +1,4 @@ +PatientLevelPredictionModule 0.0.1 +======================= + +Initial module \ No newline at end of file diff --git a/PatientLevelPredictionModule.Rproj b/PatientLevelPredictionModule.Rproj new file mode 100644 index 0000000..eaa6b81 --- /dev/null +++ b/PatientLevelPredictionModule.Rproj @@ -0,0 +1,18 @@ +Version: 1.0 + +RestoreWorkspace: Default +SaveWorkspace: Default +AlwaysSaveHistory: Default + +EnableCodeIndexing: Yes +UseSpacesForTab: Yes +NumSpacesForTab: 2 +Encoding: UTF-8 + +RnwWeave: Sweave +LaTeX: pdfLaTeX + +BuildType: Package +PackageUseDevtools: Yes +PackageInstallArgs: --no-multiarch --with-keep.source +PackageRoxygenize: rd,collate,namespace diff --git a/README.md b/README.md new file mode 100644 index 0000000..fa66f5f --- /dev/null +++ b/README.md @@ -0,0 +1,35 @@ +# PatientLevelPredictionModule + +# Introduction + +This is a module for developing patient level prediction modules. The user needs to specify a list of model designs and a model is fit per design. + + +# Technology + +PatientLevelPredictionModule is an R project. + +# System requirements + +Requires R (version 3.6.0 or higher). + +# User Documentation + +Coming Soon + +# Support + +Please use the GitHub bug tracker + +# Contributing + +Read [here](https://ohdsi.github.io/Hades/contribute.html) how you can contribute to this package. + + +# Development + +This project is being developed in RStudio. + +### Development status + +Beta diff --git a/SettingsFunctions.R b/SettingsFunctions.R new file mode 100644 index 0000000..3ded225 --- /dev/null +++ b/SettingsFunctions.R @@ -0,0 +1,18 @@ +createPatientLevelPredictionModuleSpecifications <- function( + modelDesignList +) { + #analysis <- list() + #for (name in names(formals(createCohortDiagnosticsModuleSpecifications))) { + # analysis[[name]] <- get(name) + #} + + specifications <- list( + module = "PatientLevelPredictionModule", + version = "0.0.1", + remoteRepo = "github.com", + remoteUsername = "ohdsi", + settings = modelDesignList + ) + class(specifications) <- c("PatientLevelPredictionModuleSpecifications", "ModuleSpecifications") + return(specifications) +} \ No newline at end of file diff --git a/renv.lock b/renv.lock new file mode 100644 index 0000000..7a47452 --- /dev/null +++ b/renv.lock @@ -0,0 +1,681 @@ +{ + "R" : { + "Version" : "4.2.1", + "Repositories" : [ + { + "Name" : "CRAN", + "URL" : "https://cloud.r-project.org" + } + ] + }, + "Packages" : { + "glue" : { + "Package" : "glue", + "Version" : "1.6.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "cli" : { + "Package" : "cli", + "Version" : "3.3.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rlang" : { + "Package" : "rlang", + "Version" : "1.0.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "ellipsis" : { + "Package" : "ellipsis", + "Version" : "0.3.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "fansi" : { + "Package" : "fansi", + "Version" : "1.0.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "lifecycle" : { + "Package" : "lifecycle", + "Version" : "1.0.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "magrittr" : { + "Package" : "magrittr", + "Version" : "2.0.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "pkgconfig" : { + "Package" : "pkgconfig", + "Version" : "2.0.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "utf8" : { + "Package" : "utf8", + "Version" : "1.2.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "vctrs" : { + "Package" : "vctrs", + "Version" : "0.4.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "bit" : { + "Package" : "bit", + "Version" : "4.0.4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "cpp11" : { + "Package" : "cpp11", + "Version" : "0.4.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "crayon" : { + "Package" : "crayon", + "Version" : "1.5.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "fastmap" : { + "Package" : "fastmap", + "Version" : "1.1.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "hms" : { + "Package" : "hms", + "Version" : "1.1.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "pillar" : { + "Package" : "pillar", + "Version" : "1.8.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "prettyunits" : { + "Package" : "prettyunits", + "Version" : "1.1.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "purrr" : { + "Package" : "purrr", + "Version" : "0.3.4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "R6" : { + "Package" : "R6", + "Version" : "2.5.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "backports" : { + "Package" : "backports", + "Version" : "1.4.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "bit64" : { + "Package" : "bit64", + "Version" : "4.0.5", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "cachem" : { + "Package" : "cachem", + "Version" : "1.0.6", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "generics" : { + "Package" : "generics", + "Version" : "0.1.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "progress" : { + "Package" : "progress", + "Version" : "1.2.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "Rcpp" : { + "Package" : "Rcpp", + "Version" : "1.0.8.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "tibble" : { + "Package" : "tibble", + "Version" : "3.1.7", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "tidyselect" : { + "Package" : "tidyselect", + "Version" : "1.1.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "tzdb" : { + "Package" : "tzdb", + "Version" : "0.3.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "withr" : { + "Package" : "withr", + "Version" : "2.5.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "assertthat" : { + "Package" : "assertthat", + "Version" : "0.2.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "blob" : { + "Package" : "blob", + "Version" : "1.2.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "checkmate" : { + "Package" : "checkmate", + "Version" : "2.1.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "clipr" : { + "Package" : "clipr", + "Version" : "0.8.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "colorspace" : { + "Package" : "colorspace", + "Version" : "2.0-3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "DBI" : { + "Package" : "DBI", + "Version" : "1.1.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "dplyr" : { + "Package" : "dplyr", + "Version" : "1.0.9", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "lattice" : { + "Package" : "lattice", + "Version" : "0.20-45", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "memoise" : { + "Package" : "memoise", + "Version" : "2.0.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "plogr" : { + "Package" : "plogr", + "Version" : "0.2.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rJava" : { + "Package" : "rJava", + "Version" : "1.0-6", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "stringi" : { + "Package" : "stringi", + "Version" : "1.7.8", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "triebeard" : { + "Package" : "triebeard", + "Version" : "0.3.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "vroom" : { + "Package" : "vroom", + "Version" : "1.5.7", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "dbplyr" : { + "Package" : "dbplyr", + "Version" : "2.2.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "farver" : { + "Package" : "farver", + "Version" : "2.1.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "jsonlite" : { + "Package" : "jsonlite", + "Version" : "1.8.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "labeling" : { + "Package" : "labeling", + "Version" : "0.4.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "Matrix" : { + "Package" : "Matrix", + "Version" : "1.4-1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "munsell" : { + "Package" : "munsell", + "Version" : "0.5.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "nlme" : { + "Package" : "nlme", + "Version" : "3.1-158", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "RColorBrewer" : { + "Package" : "RColorBrewer", + "Version" : "1.1-3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "readr" : { + "Package" : "readr", + "Version" : "2.1.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rprojroot" : { + "Package" : "rprojroot", + "Version" : "2.0.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "RSQLite" : { + "Package" : "RSQLite", + "Version" : "2.2.13", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "snow" : { + "Package" : "snow", + "Version" : "0.4-4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "SqlRender" : { + "Package" : "SqlRender", + "Version" : "1.9.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "stringr" : { + "Package" : "stringr", + "Version" : "1.4.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "urltools" : { + "Package" : "urltools", + "Version" : "1.7.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "viridisLite" : { + "Package" : "viridisLite", + "Version" : "0.4.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "xml2" : { + "Package" : "xml2", + "Version" : "1.3.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "zip" : { + "Package" : "zip", + "Version" : "2.2.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "Andromeda" : { + "Package" : "Andromeda", + "Version" : "0.6.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "BH" : { + "Package" : "BH", + "Version" : "1.78.0-0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "DatabaseConnector" : { + "Package" : "DatabaseConnector", + "Version" : "5.0.4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "digest" : { + "Package" : "digest", + "Version" : "0.6.29", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "gtable" : { + "Package" : "gtable", + "Version" : "0.3.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "here" : { + "Package" : "here", + "Version" : "1.0.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "isoband" : { + "Package" : "isoband", + "Version" : "0.2.5", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "MASS" : { + "Package" : "MASS", + "Version" : "7.3-58", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "mgcv" : { + "Package" : "mgcv", + "Version" : "1.8-40", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "ParallelLogger" : { + "Package" : "ParallelLogger", + "Version" : "3.0.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "plyr" : { + "Package" : "plyr", + "Version" : "1.8.7", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "png" : { + "Package" : "png", + "Version" : "0.1-7", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rappdirs" : { + "Package" : "rappdirs", + "Version" : "0.3.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "RcppEigen" : { + "Package" : "RcppEigen", + "Version" : "0.3.3.9.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "RcppTOML" : { + "Package" : "RcppTOML", + "Version" : "0.1.7", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "scales" : { + "Package" : "scales", + "Version" : "1.2.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "survival" : { + "Package" : "survival", + "Version" : "3.3-1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "Cyclops" : { + "Package" : "Cyclops", + "Version" : "3.2.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "ggplot2" : { + "Package" : "ggplot2", + "Version" : "3.3.6", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "gridExtra" : { + "Package" : "gridExtra", + "Version" : "2.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "memuse" : { + "Package" : "memuse", + "Version" : "4.2-1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "polspline" : { + "Package" : "polspline", + "Version" : "1.1.20", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "pROC" : { + "Package" : "pROC", + "Version" : "1.18.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "PRROC" : { + "Package" : "PRROC", + "Version" : "1.3.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "reticulate" : { + "Package" : "reticulate", + "Version" : "1.25", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "tidyr" : { + "Package" : "tidyr", + "Version" : "1.2.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "RJSONIO" : { + "Package" : "RJSONIO", + "Version" : "1.3-1.6", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "ps" : { + "Package" : "ps", + "Version" : "1.7.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "desc" : { + "Package" : "desc", + "Version" : "1.4.1", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "diffobj" : { + "Package" : "diffobj", + "Version" : "0.3.5", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "processx" : { + "Package" : "processx", + "Version" : "3.5.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rematch2" : { + "Package" : "rematch2", + "Version" : "2.1.2", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "rstudioapi" : { + "Package" : "rstudioapi", + "Version" : "0.13", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "brio" : { + "Package" : "brio", + "Version" : "1.1.3", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "callr" : { + "Package" : "callr", + "Version" : "3.7.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "evaluate" : { + "Package" : "evaluate", + "Version" : "0.15", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "pkgload" : { + "Package" : "pkgload", + "Version" : "1.2.4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "praise" : { + "Package" : "praise", + "Version" : "1.0.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "waldo" : { + "Package" : "waldo", + "Version" : "0.4.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "testthat" : { + "Package" : "testthat", + "Version" : "3.1.4", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "lubridate" : { + "Package" : "lubridate", + "Version" : "1.8.0", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "renv" : { + "Package" : "renv", + "Version" : "0.15.5", + "Source" : "Repository", + "Repository" : "CRAN" + }, + "FeatureExtraction" : { + "Package" : "FeatureExtraction", + "Version" : "3.2.0", + "Source" : "GitHub", + "RemoteType" : "github", + "RemoteHost" : "api.github.com", + "RemoteRepo" : "FeatureExtraction", + "RemoteUsername" : "ohdsi", + "RemoteRef" : "v3.2.0" + }, + "PatientLevelPrediction" : { + "Package" : "PatientLevelPrediction", + "Version" : "6.0.4", + "Source" : "GitHub", + "RemoteType" : "github", + "RemoteHost" : "api.github.com", + "RemoteRepo" : "PatientLevelPrediction", + "RemoteUsername" : "ohdsi", + "RemoteRef" : "04a5efdabac0a894badbbc45b676b4350d5ead00" + }, + "CirceR" : { + "Package" : "CirceR", + "Version" : "1.1.1", + "Source" : "GitHub", + "RemoteType" : "github", + "RemoteHost" : "api.github.com", + "RemoteRepo" : "CirceR", + "RemoteUsername" : "ohdsi", + "RemoteRef" : "v1.1.1" + }, + "Eunomia" : { + "Package" : "Eunomia", + "Version" : "1.0.2", + "Source" : "GitHub", + "RemoteType" : "github", + "RemoteHost" : "api.github.com", + "RemoteRepo" : "Eunomia", + "RemoteUsername" : "ohdsi", + "RemoteRef" : "v1.0.2" + }, + "CohortGenerator" : { + "Package" : "CohortGenerator", + "Version" : "0.6.0", + "Source" : "GitHub", + "RemoteType" : "github", + "RemoteHost" : "api.github.com", + "RemoteRepo" : "CohortGenerator", + "RemoteUsername" : "ohdsi", + "RemoteRef" : "v0.6.0" + } + } +} 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) + +})