backports/0000755000176200001440000000000014623633312012245 5ustar liggesusersbackports/NAMESPACE0000644000176200001440000000462414616630245013476 0ustar liggesusers# Generated by roxygen2: do not edit by hand export(import) if (getRversion() < "3.2.0") export(URLencode) if (getRversion() < "3.2.0") export(anyNA) if (getRversion() < "3.2.0") export(dir.exists) if (getRversion() < "3.2.0") export(file.info) if (getRversion() < "3.2.0") export(file.mode) if (getRversion() < "3.2.0") export(file.mtime) if (getRversion() < "3.2.0") export(file.size) if (getRversion() < "3.2.0") export(get0) if (getRversion() < "3.2.0") export(isNamespaceLoaded) if (getRversion() < "3.2.0") export(lengths) if (getRversion() < "3.2.0") export(trimws) if (getRversion() < "3.3.0") export(capture.output) if (getRversion() < "3.3.0") export(endsWith) if (getRversion() < "3.3.0") export(startsWith) if (getRversion() < "3.3.0") export(strrep) if (getRversion() < "3.4.0") export(.valid.factor) if (getRversion() < "3.4.0") export(hasName) if (getRversion() < "3.5.0") export(...elt) if (getRversion() < "3.5.0") export(...length) if (getRversion() < "3.5.0") export(isFALSE) if (getRversion() < "3.5.0") export(isTRUE) if (getRversion() < "3.6.0") export(asplit) if (getRversion() < "3.6.0") export(dQuote) if (getRversion() < "3.6.0") export(errorCondition) if (getRversion() < "3.6.0") export(removeSource) if (getRversion() < "3.6.0") export(sQuote) if (getRversion() < "3.6.0") export(str2expression) if (getRversion() < "3.6.0") export(str2lang) if (getRversion() < "3.6.0") export(vignetteInfo) if (getRversion() < "3.6.0") export(warningCondition) if (getRversion() < "4.0.0") export(R_user_dir) if (getRversion() < "4.0.0") export(deparse1) if (getRversion() < "4.0.0") export(list2DF) if (getRversion() < "4.0.0") export(stopifnot) if (getRversion() < "4.0.0") export(suppressMessages) if (getRversion() < "4.0.0") export(suppressWarnings) if (getRversion() < "4.0.1") export(paste) if (getRversion() < "4.0.1") export(paste0) if (getRversion() < "4.1.0") export(...names) if (getRversion() < "4.1.0") export(.libPaths) if (getRversion() < "4.3.0") S3method("as.Rconcordance", "default") if (getRversion() < "4.3.0") S3method("as.character", "Rconcordance") if (getRversion() < "4.3.0") S3method("print", "Rconcordance") if (getRversion() < "4.3.0") export(as.Rconcordance) if (getRversion() < "4.3.0") export(matchConcordance) if (getRversion() < "4.4.0") export(`%||%`) importFrom(utils,getFromNamespace) importFrom(utils,head) useDynLib(backports,dotsElt) useDynLib(backports,dotsLength) useDynLib(backports,dotsNames) backports/.aspell/0000755000176200001440000000000014402606025013577 5ustar liggesusersbackports/.aspell/backports.rds0000644000176200001440000000012514402606025016277 0ustar liggesusers‹‹àb```b`f’Ì@&ƒ³2°0piޤÄäì‚ü¢(ŸÓ Ê/† $¡ ¥fæ䤿¦æ•$–dæçÁ%ŠÐ%_U¶+zbackports/.aspell/defaults.R0000644000176200001440000000021414402606025015526 0ustar liggesusersRd_files <- vignettes <- R_files <- description <- list(encoding = "UTF-8", language = "en", dictionaries = c("en_stats", "backports")) backports/README.md0000644000176200001440000001077714402606025013534 0ustar liggesusers# backports [![CRAN_Status_Badge](https://www.r-pkg.org/badges/version/backports)](https://cran.r-project.org/package=backports) [![R-CMD-check](https://github.com/r-lib/backports/workflows/R-CMD-check/badge.svg)](https://github.com/r-lib/backports/actions) [![Download Stats](http://cranlogs.r-pkg.org/badges/backports)](https://cran.r-project.org/package=backports) This package provides backports of functions which have been introduced in one of the base packages in R version 3.0.1 or later. The backports are conditionally exported in order to let R resolve the function name to either the implemented backport, or the respective base version, if available. Package developers can make use of new functions or arguments by selectively importing specific backports to support older installations. ## Usage ### Interactively Attach the namespace via `library(backports)`. Note that it is crucial that `backports` is build against the currently running R version. Do not ignore these kind of warnings for this package. ### In packages 1. Add backports to your DESCRIPTION under `Imports`. 2. Add or modify the function `.onLoad()` (see [here](https://stat.ethz.ch/R-manual/R-devel/library/base/html/ns-hooks.html)) to call the `import()` function of backports: ```r .onLoad <- function(libname, pkgname) { backports::import(pkgname) } ``` You can also selectively import functions: ```r .onLoad <- function(libname, pkgname) { backports::import(pkgname, c("get0", "dir.exists")) } ``` If you set `force = TRUE`, the provided functions will get imported, regardless of the R version: ```r .onLoad <- function(libname, pkgname) { backports::import(pkgname, "hasName", force = TRUE) } ``` 3. [Optional] Set `Depends` in your DESCRIPTION to require `R (>= 3.0.0)`. ### Importing backports from `utils` or `tools` Backports for functions which are not in the `base` require additional steps. Usually, you need to to import those functions in the package NAMESPACE. However, this is only possible if such a function really exists, and yields a warning during `R CMD check` for older versions. There are three possibilities to deal with this: 1. Completely import the namespaces instead of selectively importing them, e.g. use `import(utils)` instead of `importFrom(utils, hasName)` in your `NAMESPACE` file. 2. Force-import the function (see above) so that you always use the backport instead of the implementation shipped with R, even for the most recent version of R. 3. Use a conditional import in your `NAMESPACE` file, e.g. ``` if (getRversion() >= "3.4.0") { importFrom(utils, hasName) } else { importFrom(backports, hasName) } ``` Note that the braces `{}` are necessary in the `NAMESPACE` file, even though they wouldn't be for regular R code, and that you might get a warning for including `backports` in the `Imports:` section of your `DESCRIPTION` file if you never end up using it. ## Backports for R versions prior to 3.2.0 * `base::anyNA()` * `base::dir.exists()` * `base::file.size()`, `base::file.mode()` and `base::file.mtime()` * `base::lengths()` * Argument `extra_cols` for `base::file.info()` * Argument `repeated` for `utils::URLencode` * `base::isNamespaceLoaded()` ## Backports for R versions prior to 3.3.0 * `base::startsWith()` and `base::endsWith()` * `base::strrep()` * `base::trimws()` * Argument `type` for `utils::capture.output()` ## Backports for R versions prior to 3.4.0 * `base::.valid.factor()` * `utils::hasName()` ## Backports for R versions prior to 3.5.0 * `base::...length()` * `base::...elt()` * `base::isFALSE()` ## Backports for R versions prior to 3.6.0 * `base::warningCondition()` * `base::errorCondition()` * Argument `q` for `base::dQuote()` and `base::sQuote()` * `tools::vignetteInfo()` * `base::str2lang()` * `base::str2expression()` * `base::asplit()` * `utils::removeSource()` with the capability to strip source from language objects. ## Backports for R versions prior to 4.0.0 * `base::deparse1()` * `base::list2DF()` * `tools::R_user_dir()` * Argument `classes` for `base::suppressWarnings()` and `base::suppressMessages()` ## Backports for R versions prior to 4.0.1 * Argument `recycle0` for `base::paste()`. * Argument `recycle0` for `base::paste0()`. ## Backports for R versions prior to 4.1.0 * `base::...names()` * `base::.libPaths()` ## Backports for R versions prior to 4.3.0 * `tools:::print.Rconcordance` * `tools:::as.character.Rconcordance` * `tools::as.Rconcordance` * `tools:::as.Rconcordance.default` * `tools::matchConcordance` backports/man/0000755000176200001440000000000014623357545013033 5ustar liggesusersbackports/man/dir.exists.Rd0000644000176200001440000000076314402606025015405 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/dir.exists.R \name{dir.exists} \alias{dir.exists} \title{Backport of dir.exists for R < 3.2.0} \usage{ dir.exists(paths) } \description{ See the original description in \code{base::dir.exists}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_dir.exists = getFromNamespace("dir.exists", "backports") bp_dir.exists(tempdir()) } \keyword{internal} backports/man/import.Rd0000644000176200001440000000276714402606025014631 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/import.R \name{import} \alias{import} \title{Import backported functions into your package} \usage{ import(pkgname, obj = NULL, force = FALSE) } \arguments{ \item{pkgname}{[\code{character(1)}]\cr Name of the package where the backported function should be assigned.} \item{obj}{[\code{character}]\cr Name of objects to assign, as character vector. If \code{NULL}, all backports which are not provided by R itself are assigned.} \item{force}{[\code{logical}]\cr If \code{obj} is provided and \code{force} is set to \code{FALSE}, only backports not provided by the base package of the executing R interpreter are imported. Set to \code{TRUE} to ignore this check and always import the backport into the package's namespace.} } \description{ Imports objects from \pkg{backports} into the namespace of other packages by assigning it during load-time. See examples for a code snippet to copy to your package. } \examples{ \dontrun{ # This imports all functions implemented in backports while the package is loaded .onLoad <- function(libname, pkgname) { backports::import(pkgname) } # This only imports the function "trimws" .onLoad <- function(libname, pkgname) { backports::import(pkgname, "trimws") } # This imports all backports from base and force-imports "hasName" from utils .onLoad <- function(libname, pkgname) { backports::import(pkgname) backports::import(pkgname, "hasName", force = TRUE) } } } \seealso{ \code{\link{.onLoad}} } backports/man/file.size.Rd0000644000176200001440000000143314402606025015174 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/file.mode.R, R/file.mtime.R, R/file.size.R \name{file.mode} \alias{file.mode} \alias{file.mtime} \alias{file.size} \title{Backports of wrappers around \code{file.info} for R < 3.2.0} \usage{ file.mode(...) file.mtime(...) file.size(...) } \description{ See the original description in \code{base::file.size}. } \examples{ # get functions from namespace instead of possibly getting # implementations shipped with recent R versions: bp_file.size = getFromNamespace("file.size", "backports") bp_file.mode = getFromNamespace("file.size", "backports") bp_file.mtime = getFromNamespace("file.size", "backports") fn = file.path(R.home(), "COPYING") bp_file.size(fn) bp_file.mode(fn) bp_file.size(fn) } \keyword{internal} backports/man/deparse1.Rd0000644000176200001440000000102114402606025015001 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/deparse1.R \name{deparse1} \alias{deparse1} \title{Backport of deparse1 for R < 4.0.0} \usage{ deparse1(expr, collapse = " ", width.cutoff = 500L, ...) } \description{ See the original description in \code{base::deparse1}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_deparse1 = getFromNamespace("deparse1", "backports") bp_deparse1(quote(`foo bar`)) } \keyword{internal} backports/man/asplit.Rd0000644000176200001440000000074314402606025014603 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/asplit.R \name{asplit} \alias{asplit} \title{Backport of asplit for R < 3.6.0} \usage{ asplit(x, MARGIN) } \description{ See the original description in \code{base::asplit}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_asplit = getFromNamespace("asplit", "backports") x = matrix(1:6, 2, 3) bp_asplit(x, 1) } \keyword{internal} backports/man/matchConcordance.Rd0000644000176200001440000000052514402606025016540 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Rconcordance.R \name{matchConcordance} \alias{matchConcordance} \title{Backport of matchConcordance for R < 4.3.0} \usage{ matchConcordance(linenum, concordance) } \description{ See the original description in \code{tools::matchConcordance}. } \keyword{internal} backports/man/file.info.Rd0000644000176200001440000000113314402606025015152 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/file.info.R \name{file.info} \alias{file.info} \title{Backport of \code{file.info} for R < 3.2.0} \usage{ file.info(..., extra_cols = TRUE) } \description{ Argument \code{extra_cols} has been backported. See the original description in \code{base::file.info}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_file.info = getFromNamespace("file.info", "backports") bp_file.info(file.path(R.home(), "COPYING"), extra_cols = FALSE) } \keyword{internal} backports/man/libPaths.Rd0000644000176200001440000000070114402606025015047 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/libPaths.R \name{.libPaths} \alias{.libPaths} \title{Backport of .libPaths for R < 4.1.0} \usage{ .libPaths(new, include.site = TRUE) } \description{ See the original description in \code{base::.libPaths}. } \examples{ save <- .libPaths() save # ignore the site library .libPaths("test", include.site = FALSE) # restore the original .libPaths(save) } \keyword{internal} backports/man/as.character.Rconcordance.Rd0000644000176200001440000000061714402606025020244 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Rconcordance.R \name{as.character.Rconcordance} \alias{as.character.Rconcordance} \title{Backport of as.character.Rconcordance for R < 4.3.0} \usage{ \method{as.character}{Rconcordance}(x, targetfile = "", ...) } \description{ See the original description in \code{tools::as.character.Rconcordance}. } \keyword{internal} backports/man/print.Rconcordance.Rd0000644000176200001440000000053314402606025017037 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Rconcordance.R \name{print.Rconcordance} \alias{print.Rconcordance} \title{Backport of print.Rconcordance for R < 4.3.0} \usage{ \method{print}{Rconcordance}(x, ...) } \description{ See the original description in \code{tools::print.Rconcordance}. } \keyword{internal} backports/man/isFALSE.Rd0000644000176200001440000000074114402606025014473 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/isFALSE.R \name{isFALSE} \alias{isFALSE} \title{Backport of isFALSE for R < 3.4.2} \usage{ isFALSE(x) } \description{ See the original description in \code{base::isFALSE}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_isFALSE = getFromNamespace("isFALSE", "backports") bp_isFALSE(FALSE) bp_isFALSE(iris) } \keyword{internal} backports/man/URLencode.Rd0000644000176200001440000000115514402606025015125 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/URLencode.R \name{URLencode} \alias{URLencode} \title{Backport of URLencode for R < 3.2.0} \usage{ URLencode(URL, reserved = FALSE, repeated = FALSE) } \description{ See the original description in \code{utils::URLencode}. Argument \code{repeated} is backported. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_URLencode = getFromNamespace("URLencode", "backports") URLdecode(z <- "ab\%20cd") c(bp_URLencode(z), bp_URLencode(z, repeated = TRUE)) } \keyword{internal} backports/man/suppressWarnings.Rd0000644000176200001440000000142214402606025016677 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/suppressWarnings.R \name{suppressWarnings} \alias{suppressWarnings} \alias{suppressMessages} \title{Backport of suppressWarnings and suppressMessages for R < 4.0.0} \usage{ suppressWarnings(expr, classes = "warning") suppressMessages(expr, classes = "message") } \description{ Backport for new argument `classes`. See the original description in \code{base::suppressWarnings}/\code{base::suppressMessages}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_suppressWarnings = getFromNamespace("suppressWarnings", "backports") bp_suppressWarnings(warningCondition("warning", class = "testWarning"), "testWarning") } \keyword{internal} backports/man/as.Rconcordance.Rd0000644000176200001440000000050214402606025016302 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Rconcordance.R \name{as.Rconcordance} \alias{as.Rconcordance} \title{Backport of as.Rconcordance for R < 4.3.0} \usage{ as.Rconcordance(x, ...) } \description{ See the original description in \code{tools::as.Rconcordance}. } \keyword{internal} backports/man/list2DF.Rd0000644000176200001440000000130314402606025014547 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/list2DF.R \name{list2DF} \alias{list2DF} \title{Backport of list2DF for R < 4.0.0} \usage{ list2DF(x = list(), nrow = 0L) } \description{ See the original description in \code{base::list2DF}. Note that the behaviour of \code{list2DF()} changed in R 4.2.0. Instead of recycling vectors to common length, an exception is raised. This backport implements the new behaviour, throwing an error message. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_list2DF = getFromNamespace("list2DF", "backports") bp_list2DF(list(x = 1:3, y = 2:4)) } \keyword{internal} backports/man/endsWith.Rd0000644000176200001440000000076314402606025015076 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/endsWith.R \name{endsWith} \alias{endsWith} \title{Backport of endsWith for R < 3.3.0} \usage{ endsWith(x, suffix) } \description{ See the original description in \code{base::endsWith}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_endsWith = getFromNamespace("endsWith", "backports") bp_endsWith(c("aabb", "bbcc"), "bb") } \keyword{internal} backports/man/startsWith.Rd0000644000176200001440000000100514402606025015453 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/startsWith.R \name{startsWith} \alias{startsWith} \title{Backport of startsWith for R < 3.3.0} \usage{ startsWith(x, prefix) } \description{ See the original description in \code{base::startsWith}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_startsWith = getFromNamespace("startsWith", "backports") bp_startsWith(c("aabb", "bbcc"), "bb") } \keyword{internal} backports/man/warningCondition.Rd0000644000176200001440000000132514402606025016620 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/warningCondition.R \name{warningCondition} \alias{warningCondition} \alias{errorCondition} \title{Backport of warningCondition and errorCondition for R < 3.6.0} \usage{ warningCondition(msg, ..., class = NULL, call = NULL) errorCondition(msg, ..., class = NULL, call = NULL) } \description{ See the original description in \code{base::warningCondition}/\code{base::errorCondition}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_warningCondition = getFromNamespace("warningCondition", "backports") bp_warningCondition("package backports not found") } \keyword{internal} backports/man/str2expression.Rd0000644000176200001440000000102514402606025016313 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/str2expression.R \name{str2expression} \alias{str2expression} \title{Backport of str2expression for R < 3.6.0} \usage{ str2expression(text) } \description{ See the original description in \code{base::str2expression}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: str2expression <- getFromNamespace("str2expression", "backports") str2expression("x[3] <- 1+4") } \keyword{internal} backports/man/get0.Rd0000644000176200001440000000110014402606025014132 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/get0.R \name{get0} \alias{get0} \title{Backport of get0 for R < 3.2.0} \usage{ get0( x, envir = pos.to.env(-1L), mode = "any", inherits = TRUE, ifnotfound = NULL ) } \description{ See the original description in \code{base::get0}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_get0 = getFromNamespace("get0", "backports") bp_get0("a") bp_get0("a", ifnotfound = 0) foo = 12 bp_get0("foo") } \keyword{internal} backports/man/paste.Rd0000644000176200001440000000104314402606025014415 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/paste.R \name{paste} \alias{paste} \title{Backport of paste for R < 4.0.1} \usage{ paste(..., sep = " ", collapse = NULL, recycle0 = FALSE) } \description{ See the original description in \code{base::paste}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_paste = getFromNamespace("paste", "backports") bp_paste(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) } \keyword{internal} backports/man/dotsLength.Rd0000644000176200001440000000077614402606025015430 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/dotsLength.R \name{...length} \alias{...length} \title{Backport of ...length for R < 3.4.2} \usage{ ...length() } \description{ See the original description in \code{base::...length}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_...length = getFromNamespace("...length", "backports") foo = function(...) bp_...length() foo(1, 2, 3) } \keyword{internal} backports/man/lengths.Rd0000644000176200001440000000075114402606025014752 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/lengths.R \name{lengths} \alias{lengths} \title{Backport of lengths for R < 3.2.0} \usage{ lengths(x, use.names = TRUE) } \description{ See the original description in \code{base::lengths}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_lengths = getFromNamespace("lengths", "backports") bp_lengths(list(1:3, 2)) } \keyword{internal} backports/man/valid.factor.Rd0000644000176200001440000000103014402606025015651 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/valid.factor.R \name{.valid.factor} \alias{.valid.factor} \title{Backport of .valid.factor for R < 3.4.0} \usage{ .valid.factor(object) } \description{ See the original description in \code{base::.valid.factor}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_.valid_factor = getFromNamespace(".valid.factor", "backports") bp_.valid_factor(factor(letters[1:3])) } \keyword{internal} backports/man/vignetteInfo.Rd0000644000176200001440000000075114402606025015747 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/vignetteInfo.R \name{vignetteInfo} \alias{vignetteInfo} \title{Backport of vignetteInfo for R < 3.6.0} \usage{ vignetteInfo(file) } \description{ See the original description in \code{tools::vignetteInfo}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_vignetteInfo = getFromNamespace("vignetteInfo", "backports") } \keyword{internal} backports/man/isNamespaceLoaded.Rd0000644000176200001440000000106314402606025016644 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/isNamespaceLoaded.R \name{isNamespaceLoaded} \alias{isNamespaceLoaded} \title{Backport of isNamespaceLoaded for R < 3.2.0} \usage{ isNamespaceLoaded(name) } \description{ See the original description in \code{base::isNamespaceLoaded}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_isNamespaceLoaded = getFromNamespace("isNamespaceLoaded", "backports") bp_isNamespaceLoaded("backports") } \keyword{internal} backports/man/backports-package.Rd0000644000176200001440000000201314402606025016660 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/zzz.R \docType{package} \name{backports-package} \alias{backports} \alias{backports-package} \title{backports: Reimplementations of Functions Introduced Since R-3.0.0} \description{ Functions introduced or changed since R v3.0.0 are re-implemented in this package. The backports are conditionally exported in order to let R resolve the function name to either the implemented backport, or the respective base version, if available. Package developers can make use of new functions or arguments by selectively importing specific backports to support older installations. } \seealso{ Useful links: \itemize{ \item \url{https://github.com/r-lib/backports} \item Report bugs at \url{https://github.com/r-lib/backports/issues} } } \author{ \strong{Maintainer}: Michel Lang \email{michellang@gmail.com} (\href{https://orcid.org/0000-0001-9754-0393}{ORCID}) Authors: \itemize{ \item Duncan Murdoch \email{murdoch.duncan@gmail.com} \item R Core Team } } backports/man/paste0.Rd0000644000176200001440000000104114402606025014473 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/paste0.R \name{paste0} \alias{paste0} \title{Backport of paste0 for R < 4.0.1} \usage{ paste0(..., collapse = NULL, recycle0 = FALSE) } \description{ See the original description in \code{base::paste0}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_paste0 = getFromNamespace("paste0", "backports") bp_paste0(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) } \keyword{internal} backports/man/R_user_dir.Rd0000644000176200001440000000103614402606025015400 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/R_user_dir.R \name{R_user_dir} \alias{R_user_dir} \title{Backport of R_user_dir for R < 4.0.0} \usage{ R_user_dir(package, which = c("data", "config", "cache")) } \description{ See the original description in \code{tools::R_user_dir}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_R_user_dir = getFromNamespace("R_user_dir", "backports") bp_R_user_dir("backports") } \keyword{internal} backports/man/str2lang.Rd0000644000176200001440000000073414402606025015043 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/str2lang.R \name{str2lang} \alias{str2lang} \title{Backport of str2lang for R < 3.6.0} \usage{ str2lang(s) } \description{ See the original description in \code{base::str2lang}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: str2lang <- getFromNamespace("str2lang", "backports") str2lang("x[3] <- 1+4") } \keyword{internal} backports/man/dotsElt.Rd0000644000176200001440000000076514402606025014731 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/dotsElt.R \name{...elt} \alias{...elt} \title{Backport of ...elt for R < 3.4.2} \usage{ ...elt(n) } \description{ See the original description in \code{base::...elt}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_...elt = getFromNamespace("...elt", "backports") foo = function(n, ...) bp_...elt(n) foo(n = 2, "a", "b", "c") } \keyword{internal} backports/man/stopifnot.Rd0000644000176200001440000000112714402606025015331 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/stopifnot.R \name{stopifnot} \alias{stopifnot} \title{Backport of stopifnot for R versions < 4.0.0.} \usage{ stopifnot(..., exprs, exprObject, local = TRUE) } \description{ See the original description in \code{base::stopifnot}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_stopifnot = getFromNamespace("stopifnot", "backports") m <- matrix(c(1, 3, 12, 1), 2, 2) \dontrun{bp_stopifnot("m must be symmetric" = m == t(m))} } \keyword{internal} backports/man/removeSource.Rd0000644000176200001440000000077614402606025015773 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/removeSource.R \name{removeSource} \alias{removeSource} \title{Backport of removeSource for R < 3.6.0} \usage{ removeSource(fn) } \description{ See the original description in \code{utils::removeSource}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_removeSource = getFromNamespace("removeSource", "backports") bp_removeSource(mean) } \keyword{internal} backports/man/null_coalesce_operator.Rd0000644000176200001440000000112414623357545020043 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/null_coalesce.R \name{null_coalesce_operator} \alias{null_coalesce_operator} \alias{\%||\%} \title{Backport of the null-coalescing operator for R < 4.4.0} \usage{ x \%||\% y } \arguments{ \item{x}{(any).} \item{y}{(any).} } \description{ See the original description in \code{Control}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_null_coalesce = getFromNamespace("\%||\%", "backports") bp_null_coalesce(NULL, FALSE) } \keyword{internal} backports/man/dotsNames.Rd0000644000176200001440000000077514402606025015251 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/dotsNames.R \name{...names} \alias{...names} \title{Backport of ...names for R < 4.1.0} \usage{ ...names() } \description{ See the original description in \code{base::...names}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_...names = getFromNamespace("...names", "backports") foo = function(...) bp_...names() foo(a = 1, b = 2, 3) } \keyword{internal} backports/man/hasName.Rd0000644000176200001440000000076614402606025014670 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/hasName.R \name{hasName} \alias{hasName} \title{Backport of hasName for R < 3.4.0} \usage{ hasName(x, name) } \description{ See the original description in \code{utils::hasName}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_hasName = getFromNamespace("hasName", "backports") bp_hasName(list(a = 1, b = 2), c("a", "b", "c")) } \keyword{internal} backports/man/capture.output.Rd0000644000176200001440000000131414402606025016304 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/capture.output.R \name{capture.output} \alias{capture.output} \title{Backport of capture.output for R < 3.3.0} \usage{ capture.output( ..., file = NULL, append = FALSE, type = c("output", "message"), split = FALSE ) } \description{ Argument \code{type} has been backported. See the original description in \code{utils::capture.output}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_capture.output <- getFromNamespace("capture.output", "backports") captured <- bp_capture.output({ message("hi") }, type = "message") str(captured) } \keyword{internal} backports/man/isTRUE.Rd0000644000176200001440000000121014402606025014410 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/isTRUE.R \name{isTRUE} \alias{isTRUE} \title{Backport of isTRUE for R < 3.5.0} \usage{ isTRUE(x) } \description{ The implementation of `isTRUE` has been changed in R-3.5.0 from \code{identical(x, TRUE)} to \code{is.logical(x) && length(x) == 1L && !is.na(x) && x}. This backport overloads the old implementation for R versions prior to 3.5.0. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_isTRUE = getFromNamespace("isTRUE", "backports") bp_isTRUE(FALSE) bp_isTRUE(iris) } \keyword{internal} backports/man/dQuote.Rd0000644000176200001440000000121414402606025014542 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/dQuote.R \name{dQuote} \alias{dQuote} \alias{sQuote} \title{Backport of dQuote and sQuote for R < 3.6.0} \usage{ dQuote(x, q = getOption("useFancyQuotes")) sQuote(x, q = getOption("useFancyQuotes")) } \description{ Argument \code{q} has been backported. See the original description in \code{base::dQuote()} and \code{base::sQuote()}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_dQuote <- getFromNamespace("dQuote", "backports") bp_dQuote("foo") bp_dQuote("foo", q = TRUE) } \keyword{internal} backports/man/as.Rconcordance.default.Rd0000644000176200001440000000055414402606025017734 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/Rconcordance.R \name{as.Rconcordance.default} \alias{as.Rconcordance.default} \title{Backport of as.Rconcordance.default for R < 4.3.0} \usage{ \method{as.Rconcordance}{default}(x, ...) } \description{ See the original description in \code{tools::as.Rconcordance}. } \keyword{internal} backports/man/strrep.Rd0000644000176200001440000000072014402606025014621 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/strrep.R \name{strrep} \alias{strrep} \title{Backport of strrep for R < 3.3.0} \usage{ strrep(x, times) } \description{ See the original description in \code{base::strrep}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_strrep = getFromNamespace("strrep", "backports") bp_strrep("-", 10) } \keyword{internal} backports/man/anyNA.Rd0000644000176200001440000000073514402606025014316 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/anyNA.R \name{anyNA} \alias{anyNA} \title{Backport of anyNA for R versions < 3.2.0.} \usage{ anyNA(x, recursive = FALSE) } \description{ See the original description in \code{base::anyNA}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_anyNA = getFromNamespace("anyNA", "backports") bp_anyNA(letters) } \keyword{internal} backports/man/trimws.Rd0000644000176200001440000000106214402606025014627 0ustar liggesusers% Generated by roxygen2: do not edit by hand % Please edit documentation in R/trimws.R \name{trimws} \alias{trimws} \title{Backport of trimws for R < 3.3.0} \usage{ trimws(x, which = c("both", "left", "right")) } \description{ See the original description in \code{base::trimws}. } \examples{ # get function from namespace instead of possibly getting # implementation shipped with recent R versions: bp_trimws = getFromNamespace("trimws", "backports") bp_trimws(c(" a ", "b ", " c")) bp_trimws(c(" a ", "b ", " c"), which = "left") } \keyword{internal} backports/DESCRIPTION0000644000176200001440000000241714623633312013757 0ustar liggesusersPackage: backports Type: Package Title: Reimplementations of Functions Introduced Since R-3.0.0 Version: 1.5.0 Authors@R: c( person("Michel", "Lang", NULL, "michellang@gmail.com", role = c("cre", "aut"), comment = c(ORCID = "0000-0001-9754-0393")), person("Duncan", "Murdoch", NULL, "murdoch.duncan@gmail.com", role = c("aut")), person("R Core Team", role = "aut")) Maintainer: Michel Lang Description: Functions introduced or changed since R v3.0.0 are re-implemented in this package. The backports are conditionally exported in order to let R resolve the function name to either the implemented backport, or the respective base version, if available. Package developers can make use of new functions or arguments by selectively importing specific backports to support older installations. URL: https://github.com/r-lib/backports BugReports: https://github.com/r-lib/backports/issues License: GPL-2 | GPL-3 NeedsCompilation: yes ByteCompile: yes Depends: R (>= 3.0.0) Encoding: UTF-8 RoxygenNote: 7.3.1 Packaged: 2024-05-23 11:56:25 UTC; michel Author: Michel Lang [cre, aut] (), Duncan Murdoch [aut], R Core Team [aut] Repository: CRAN Date/Publication: 2024-05-23 12:30:02 UTC backports/tests/0000755000176200001440000000000014616630243013411 5ustar liggesusersbackports/tests/test_isNamespaceLoaded.R0000644000176200001440000000024114402606025020123 0ustar liggesuserssource("helper/helper.R") expect_true(isNamespaceLoaded("base")) expect_true(isNamespaceLoaded("backports")) expect_false(isNamespaceLoaded("..notexisting..")) backports/tests/test_str2expression.R0000644000176200001440000000043714402606025017603 0ustar liggesuserssource("helper/helper.R") if (exists("str2expression", envir = baseenv())) { f = get("str2expression", envir = baseenv()) expect_same = makeCompareFun(f, backports:::str2expression) expect_same("x[3] <- 1+4") expect_same("log(y)") expect_same("abc") expect_same("1.375") } backports/tests/test_capture.output.R0000644000176200001440000000071014402606025017565 0ustar liggesuserssource("helper/helper.R") f = get("capture.output", envir = getNamespace("utils")) expect_same = makeCompareFun(f, backports:::capture.output) output = function() { print("stdout") message("stderr") } suppressMessages({ expect_same(output()) }) if (getRversion() >= "3.3.0") { suppressMessages({ expect_same(output(), type = "message") expect_same(output(), type = "output") }) expect_same(output(), type = c("message", "output")) } backports/tests/test_dotlibPaths.R0000644000176200001440000000064414402606025017046 0ustar liggesuserssource("helper/helper.R") f = get(".libPaths", envir = baseenv()) expect_same = makeCompareFun(f, backports:::.libPaths) save <- .libPaths() f <- tempfile() expect_same(f) dir.create(f) expect_same(f) if (getRversion() >= "4.1.0") { expect_same(f, include.site = FALSE) } else { .libPaths(f, include.site = FALSE) expect_same() } .libPaths(save, include.site = length(.Library.site) && .Library.site %in% save) backports/tests/test_warningCondition.R0000644000176200001440000000110614402606025020077 0ustar liggesuserssource("helper/helper.R") if (exists("warningCondition", envir = baseenv())) { f = get("warningCondition", envir = baseenv()) expect_same = makeCompareFun(f, backports:::warningCondition) expect_same("warning from backports test") expect_same("warning from backports test", class = "test_warning") } if (exists("errorCondition", envir = baseenv())) { f = get("errorCondition", envir = baseenv()) expect_same = makeCompareFun(f, backports:::errorCondition) expect_same("error from backports test") expect_same("error from backports test", class = "test_error") } backports/tests/test_dotsNames.R0000644000176200001440000000126414402606025016525 0ustar liggesuserssource("helper/helper.R") wb = function(...) backports:::...names() if (exists("...names", envir = baseenv()) && getRversion() > "4.1.2") { f = get("...names", envir = baseenv()) wf = function(...) f() expect_same = makeCompareFun(wf, wb) expect_same(1, 2) expect_same(a = 1) expect_same(1, b = 2) expect_same() expect_identical(wb(a = 1, 2), c("a", "")) } expect_identical(wb(a = 1, b = 2), c("a", "b")) # issue 64 bp_...names = getFromNamespace("...names", "backports") test1 <- function(...) { ...names() } test2 <- function(...) { bp_...names() } expect_identical( test1("ABC"), test2("ABC") ) expect_identical( test1(a = "b", ), test2(a = "b", ) ) backports/tests/test_file.mtime.R0000644000176200001440000000037014402606025016616 0ustar liggesuserssource("helper/helper.R") if (exists("file.mtime", envir = baseenv())) { f = get("file.mtime", envir = baseenv()) expect_same = makeCompareFun(f, backports:::file.mtime) expect_same(R.home()) expect_same(file.path(R.home(), "COPYING")) } backports/tests/helper/0000755000176200001440000000000014402606025014662 5ustar liggesusersbackports/tests/helper/helper.R0000644000176200001440000000156314402606025016271 0ustar liggesuserslibrary(backports) expect_identical = function(x, y) { stopifnot(identical(x, y)) } expect_true = function(x) { stopifnot(isTRUE(x)) } expect_false = function(x) { stopifnot(isFALSE(x)) } expect_error = function(x, pattern = NULL) { ok = try(eval.parent(substitute(x)), silent = TRUE) if (!inherits(ok, "try-error")) stop(deparse(substitute(x)), " did not throw an error") if (!is.null(pattern) && !grepl(pattern, as.character(ok))) stop(sprintf("Expected error message matching '%s', got '%s'", pattern, backports:::trimws(as.character(ok)))) } makeCompareFun = function(f1, f2, ...) { f1 = match.fun(f1) f2 = match.fun(f2) function(...) { r1 = try(f1(...), silent = TRUE) r2 = try(f2(...), silent = TRUE) if (inherits(r1, "try-error")) { stopifnot(inherits(r2, "try-error")) } else { expect_identical(r1, r2) } } } backports/tests/test_strrep.R0000644000176200001440000000201014402606025016075 0ustar liggesuserssource("helper/helper.R") if (exists("strrep", envir = baseenv())) { f = get("strrep", envir = baseenv()) expect_same = makeCompareFun(f, backports:::strrep) expect_same(NULL, 0) expect_same(NULL, 1) expect_same(NULL, 2) expect_same(NULL, 1:2) expect_same(character(0), 0) expect_same(character(0), 1) expect_same(character(0), 2) expect_same(character(0), 1:2) expect_same("", 0) expect_same("", 1) expect_same("", 2) expect_same("", 1:2) expect_same("a", 0) expect_same("a", 1) expect_same("a", 2) expect_same("a", 1:2) expect_same(NA, 0) expect_same(NA, 1) expect_same(NA, 1:2) expect_same(NA_character_, 0) expect_same(NA_character_, 1) expect_same(NA_character_, 2) expect_same(NA_character_, 1:2) expect_same(letters[1:2], 0) expect_same(letters[1:2], 1) expect_same(letters[1:2], 2) expect_same(letters[2:2], 1:2) expect_same(TRUE, 0) expect_same(TRUE, 1) expect_same(TRUE, 2) expect_same(TRUE, 1:2) expect_same("a", NA) expect_same("a", c(1, NA, 2)) } backports/tests/test_file.info.R0000644000176200001440000000056414402606025016443 0ustar liggesuserssource("helper/helper.R") x = tempdir() res1 = backports:::file.info(x, extra_cols = TRUE) res2 = backports:::file.info(x, extra_cols = FALSE) stopifnot(is.data.frame(res1), nrow(res1) == 1L, ncol(res1) >= 7L) stopifnot(is.data.frame(res2), nrow(res2) == 1L, ncol(res2) == 6L) expect_identical(res1, base::file.info(x)) expect_identical(res1[, 1:6, drop = FALSE], res2) backports/tests/test_trimws.R0000644000176200001440000000064514402606025016117 0ustar liggesuserssource("helper/helper.R") if (exists("trimws", envir = baseenv())) { f = get("trimws", envir = baseenv()) expect_same = makeCompareFun(f, backports:::trimws) expect_same("") expect_same(NA) expect_same(NA_character_) expect_same(sprintf(" %s ", letters)) expect_same(" x ") expect_same(" x ", which = "both") expect_same(" x ", which = "left") expect_same(" x ", which = "right") expect_same(1) } backports/tests/test_asplit.R0000644000176200001440000000046214402606025016063 0ustar liggesuserssource("helper/helper.R") if (exists("asplit", envir = baseenv())) { f = get("asplit", envir = baseenv()) expect_same = makeCompareFun(f, backports:::asplit) d <- 2 : 4 x <- array(seq_len(prod(d)), d) expect_same(x, 2) expect_same(x, c(1, 2)) x <- matrix(1 : 6, 2, 3) expect_same(x, 1) } backports/tests/test_null_coalesce.R0000644000176200001440000000022414616630215017400 0ustar liggesuserssource("helper/helper.R") expect_identical(NULL %||% TRUE, TRUE) expect_identical(FALSE %||% NULL, FALSE) expect_identical(FALSE %||% TRUE, FALSE) backports/tests/test_hasName.R0000644000176200001440000000047314402606025016145 0ustar liggesuserssource("helper/helper.R") if (exists("hasName", envir = getNamespace("utils"))) { f = get("hasName", envir = getNamespace("utils")) expect_same = makeCompareFun(f, backports:::hasName) x = list(1, a = 12, bbb = 99) expect_same(x, "a") expect_same(x, "c") expect_same(x, "bbb") expect_same(x, "b") } backports/tests/test_removeSource.R0000644000176200001440000000034414402606025017244 0ustar liggesuserssource("helper/helper.R") if (exists("removeSource", envir = getNamespace("utils"))) { f = get("removeSource", envir = getNamespace("utils")) expect_same = makeCompareFun(f, backports:::removeSource) expect_same(mean) } backports/tests/test_deparse1.R0000644000176200001440000000054214402606025016272 0ustar liggesuserssource("helper/helper.R") if (exists("deparse1", envir = baseenv())) { f = get("deparse1", envir = baseenv()) expect_same = makeCompareFun(f, backports:::deparse1) expect_same(args(stats::lm)) e = quote(`foo bar`) expect_same(e) expect_same(e, backtick = TRUE) e = quote(`foo bar`+1) expect_same(e) expect_same(e, control = "all") } backports/tests/test_lengths.R0000644000176200001440000000047114402606025016233 0ustar liggesuserssource("helper/helper.R") if (exists("lengths", envir = baseenv())) { f = get("lengths", envir = baseenv()) expect_same = makeCompareFun(f, backports:::lengths) expect_same(1:3) expect_same(setNames(1:3, letters[1:3])) expect_same(setNames(1:3, letters[1:3]), use.names = FALSE) expect_same(iris) } backports/tests/test_isTRUE.R0000644000176200001440000000035314402606025015701 0ustar liggesuserssource("helper/helper.R") f = backports:::isTRUE expect_identical(f(TRUE), TRUE) expect_identical(f(FALSE), FALSE) expect_identical(f(1), FALSE) expect_identical(f(iris), FALSE) expect_identical(f(structure(TRUE, foo = "bar")), TRUE) backports/tests/test_R_user_dir.R0000644000176200001440000000054714402606025016670 0ustar liggesuserssource("helper/helper.R") if (exists("R_user_dir", envir = asNamespace("tools"))) { f = get("R_user_dir", envir = asNamespace("tools")) expect_same = makeCompareFun(f, backports:::R_user_dir) expect_same("backports") expect_same("backports", which = "data") expect_same("backports", which = "config") expect_same("backports", which = "cache") } backports/tests/test_Rconcordance.R0000644000176200001440000000117014402606025017164 0ustar liggesuserssource("helper/helper.R") if (exists("as.Rconcordance", envir = asNamespace("tools"), inherits = FALSE)) { f <- get("as.Rconcordance", envir = asNamespace("tools")) expect_same <- makeCompareFun(f, backports:::as.Rconcordance.default) expect_same("") } if (exists("matchConcordance", envir = asNamespace("tools"), inherits = FALSE)) { f = get("matchConcordance", envir = asNamespace("tools")) expect_same = makeCompareFun(f, backports:::matchConcordance) conc <- tools::as.Rconcordance("") expect_same(20, conc) } backports/tests/test_str2lang.R0000644000176200001440000000041514402606025016321 0ustar liggesuserssource("helper/helper.R") if (exists("str2lang", envir = baseenv())) { f = get("str2lang", envir = baseenv()) expect_same = makeCompareFun(f, backports:::str2lang) expect_same("x[3] <- 1+4") expect_same("log(y)") expect_same("abc") expect_same("1.375") } backports/tests/test_anyNA.R0000644000176200001440000000061114402606025015571 0ustar liggesuserssource("helper/helper.R") if (exists("anyNA", envir = baseenv())) { f = get("anyNA", envir = baseenv()) expect_same = makeCompareFun(f, backports:::anyNA) expect_same(1) expect_same(NA) expect_same(iris) if (getRversion() >= "3.2.0") { expect_same(list(1, 2, list(3, 4, list(NA))), recursive = FALSE) expect_same(list(1, 2, list(3, 4, list(NA))), recursive = TRUE) } } backports/tests/test_file.size.R0000644000176200001440000000036514402606025016461 0ustar liggesuserssource("helper/helper.R") if (exists("file.size", envir = baseenv())) { f = get("file.size", envir = baseenv()) expect_same = makeCompareFun(f, backports:::file.size) expect_same(R.home()) expect_same(file.path(R.home(), "COPYING")) } backports/tests/test_dQuote.R0000644000176200001440000000067014402606025016031 0ustar liggesuserssource("helper/helper.R") f = get("dQuote", envir = baseenv()) expect_same = makeCompareFun(f, backports:::dQuote) expect_same("foo") if (getRversion() >= "3.6.0") { expect_same("foo", q = TRUE) expect_same("foo", q = FALSE) } f = get("sQuote", envir = baseenv()) expect_same = makeCompareFun(f, backports:::sQuote) expect_same("foo") if (getRversion() > "3.6.0") { expect_same("foo", q = TRUE) expect_same("foo", q = FALSE) } backports/tests/test_file.mode.R0000644000176200001440000000036514402606025016433 0ustar liggesuserssource("helper/helper.R") if (exists("file.mode", envir = baseenv())) { f = get("file.mode", envir = baseenv()) expect_same = makeCompareFun(f, backports:::file.mode) expect_same(R.home()) expect_same(file.path(R.home(), "COPYING")) } backports/tests/test_dotsElt.R0000644000176200001440000000101214402606025016175 0ustar liggesuserssource("helper/helper.R") wb = function(n, ...) backports:::...elt(n) if (exists("...elt", envir = baseenv())) { f = get("...elt", envir = baseenv()) wf = function(n, ...) f(n) expect_same = makeCompareFun(wf, wb) expect_same(1, 1, 2, 3) expect_same(2, 1, 2, 3) expect_same(3, 1, 2, 3) } expect_identical(wb(1, "a", "b", "c"), "a") expect_identical(wb(2, "a", "b", "c"), "b") expect_identical(wb(3, "a", "b", "c"), "c") expect_error(wb(0, "a"), "non-positive") expect_error(wb(2, "a"), "does not contain") backports/tests/test_valid.factor.R0000644000176200001440000000124114402606025017137 0ustar liggesuserssource("helper/helper.R") f = backports:::.valid.factor x = factor(letters[1:3]) expect_identical(f(x), TRUE) x = 1:2 attr(x, "levels") = c("a", "a") expect_true(is.character(.valid.factor(x))) if (exists(".valid.factor", envir = baseenv())) { f = get(".valid.factor", envir = baseenv()) expect_same = makeCompareFun(f, backports:::.valid.factor) expect_same(letters[1:2]) expect_same(NULL) expect_same(iris) expect_same(factor("a")) expect_same(factor(1:3, levels = 1:3)) x = 1:2 class(x) = "factor" attr(x, "levels") = c("a", "b") expect_same(x) attr(x, "levels") = c("a", "a") expect_same(x) attr(x, "levels") = 1:2 expect_same(x) } backports/tests/test_isFALSE.R0000644000176200001440000000035514402606025015756 0ustar liggesuserssource("helper/helper.R") f = backports:::isFALSE expect_identical(f(FALSE), TRUE) expect_identical(f(TRUE), FALSE) expect_identical(f(1), FALSE) expect_identical(f(iris), FALSE) expect_identical(f(structure(FALSE, foo = "bar")), TRUE) backports/tests/test_suppressWarnings.R0000644000176200001440000000043414402606025020163 0ustar liggesuserssource("helper/helper.R") if (getRversion() >= "4.0.0") { f = get("suppressWarnings", envir = baseenv()) expect_same = makeCompareFun(f, backports:::suppressWarnings) expect_same(suppressWarnings(backports:::warningCondition("foo", "testWarning")), classes = "testWarning") } backports/tests/test_get0.R0000644000176200001440000000151214402606025015423 0ustar liggesuserssource("helper/helper.R") if (exists("get0", envir = baseenv())) { f = get("get0", envir = baseenv()) expect_same = makeCompareFun(f, backports:::get0) foo = 1 ee = new.env() ee$bar = 1 ee$foobar = function(x) x^2 expect_same(character(0), ifnotfound = 1) expect_same(NA_character_, ifnotfound = 1) expect_same(factor("a"), ifnotfound = 1) expect_same("bar") expect_same("bar", ifnotfound = 42) expect_same("foo") expect_same("foo", ifnotfound = 42) expect_same(c("foo", "bar", "iris"), ifnotfound = 42) expect_same(c("bar", "foo", "iris"), ifnotfound = 42) expect_same(c("iris", "foo", "bar"), ifnotfound = 42) expect_same("bar", envir = ee) expect_same("bar", envir = ee, mode = "function") expect_same("bar", envir = ee, mode = "function") expect_same("foobar", envir = ee, mode = "function") } backports/tests/test_paste.R0000644000176200001440000000475714402606025015716 0ustar liggesuserssource("helper/helper.R") if (getRversion() >= "4.0.0") { f = get("paste", envir = baseenv()) expect_same = makeCompareFun(f, backports:::paste) expect_same(letters[1:3], character()) expect_same(letters[1:3], character(), recycle0 = TRUE) expect_same(letters[1:3], character(), sep = "_", recycle0 = TRUE) expect_same(letters[1:3], character(), sep = "_", collapse = "+", recycle0 = TRUE) expect_same(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) expect_same(letters[1:3], character(), sep = NULL, recycle0 = TRUE) expect_same(letters[1:3], character(), sep = NULL, collapse = NULL, recycle0 = TRUE) expect_same(letters[1:3], character(), sep = character(), collapse = character(), recycle0 = TRUE) expect_same(character()) expect_same(character(), recycle0 = TRUE) expect_same(character(), sep = "_", recycle0 = TRUE) expect_same(character(), sep = "_", collapse = "+", recycle0 = TRUE) expect_same(character(), collapse = NULL, recycle0 = TRUE) expect_same(character(), sep = NULL, recycle0 = TRUE) expect_same(character(), sep = NULL, collapse = NULL, recycle0 = TRUE) expect_same(character(), sep = character(), collapse = character(), recycle0 = TRUE) f = get("paste0", envir = baseenv()) expect_same = makeCompareFun(f, backports:::paste0) expect_same(letters[1:3], character()) expect_same(letters[1:3], character(), recycle0 = TRUE) expect_same(letters[1:3], character(), recycle0 = TRUE) expect_same(letters[1:3], character(), collapse = "+", recycle0 = TRUE) expect_same(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) expect_same(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) expect_same(letters[1:3], character(), collapse = character(), recycle0 = TRUE) expect_same(character()) expect_same(character(), recycle0 = TRUE) expect_same(character(), recycle0 = TRUE) expect_same(character(), collapse = "+", recycle0 = TRUE) expect_same(character(), collapse = NULL, recycle0 = TRUE) expect_same(character(), collapse = NULL, recycle0 = TRUE) expect_same(character(), collapse = character(), recycle0 = TRUE) } expect_identical( paste(letters[1:3], character(), collapse = NULL, recycle0 = TRUE), character() ) expect_identical( paste(letters[1:3], character(), collapse = "_", recycle0 = TRUE), "" ) expect_identical( paste0(letters[1:3], character(), collapse = NULL, recycle0 = TRUE), character() ) expect_identical( paste0(letters[1:3], character(), collapse = "_", recycle0 = TRUE), "" ) backports/tests/test_startsWith.R0000644000176200001440000000412314402606025016741 0ustar liggesuserssource("helper/helper.R") if (exists("startsWith", envir = baseenv())) { f = get("startsWith", envir = baseenv()) expect_same = makeCompareFun(f, backports:::startsWith) expect_same("a", "a") expect_same(NA, "a") expect_same("a", NA) expect_same("a", "") expect_same("", "a") expect_same("", "") expect_same(c("a", NA, "b"), "b") expect_same("b", c("a", NA, "b")) expect_same(letters, c("m", NA, "")) } if (exists("endsWith", envir = baseenv())) { f = get("endsWith", envir = baseenv()) expect_same = makeCompareFun(f, backports:::endsWith) expect_same("a", "a") expect_same(NA, "a") expect_same("a", NA) expect_same("a", "") expect_same("", "a") expect_same("", "") expect_same(c("a", NA, "b"), "b") expect_same("b", c("a", NA, "b")) expect_same(letters, c("m", NA, "")) } # adapted from R's unit tests t1 = c("Foobar", "bla bla", "something", "another", "blu", "brown", "blau blüht der Enzian") t2 = c("some text", "any text") t3 = c("Martin", "Zürich", "Mächler") expect_true(all(backports:::startsWith(t1, ""))) expect_true(all(backports:::endsWith(t1, ""))) expect_true(all(backports:::endsWith(t2, ""))) expect_true(all(backports:::startsWith(t2, ""))) expect_true(all(backports:::endsWith(t3, ""))) expect_true(all(backports:::startsWith(t3, ""))) expect_true(all(backports:::endsWith(t2, "text"))) expect_true(all(backports:::endsWith(t2, " text"))) expect_identical(backports:::startsWith(t1, "b" ), c(FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE)) expect_identical(backports:::startsWith(t1, "bl"), c(FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE)) expect_identical(backports:::startsWith(t1, "bla"),c(FALSE, TRUE, FALSE, FALSE,FALSE, FALSE, TRUE)) expect_identical(backports:::endsWith(t1, "n"), c(FALSE,FALSE, FALSE, FALSE,FALSE, TRUE, TRUE)) expect_identical(backports:::endsWith(t1, "an"), c(FALSE,FALSE, FALSE, FALSE,FALSE, FALSE, TRUE)) expect_identical(backports:::startsWith(t3, "M" ), c( TRUE, FALSE, TRUE)) expect_identical(backports:::startsWith(t3, "Ma"), c( TRUE, FALSE, FALSE)) expect_identical(backports:::startsWith(t3, "Mä"), c(FALSE, FALSE, TRUE)) backports/tests/test_URLencode.R0000644000176200001440000000064514402606025016412 0ustar liggesuserssource("helper/helper.R") f = get("URLencode", envir = getNamespace("utils")) z = "ab%20cd" expect_identical(backports:::URLencode(z, repeated = TRUE), "ab%2520cd") if (getRversion() >= "3.2.0") { expect_same = makeCompareFun(f, backports:::URLencode) expect_same(z) expect_same(z, repeated = FALSE) expect_same(z, repeated = TRUE) } else { expect_identical(f(z), backports:::URLencode(z, repeated = TRUE)) } backports/tests/test_stopifnot.R0000644000176200001440000000104314402606025016610 0ustar liggesuserssource("helper/helper.R") expect_silent = function(x) { ok = try(eval.parent(substitute(x)), silent = TRUE) if (inherits(ok, "try-error")) stop(deparse(substitute(x)), " threw an error") } f = backports:::stopifnot expect_error(f("Test" = 1 == 2), "Test") expect_silent(f("Test" = 1 == 1)) expect_error(f("Test 1" = 1 == 2, "Test 2" = 2 == 2), "Test 1") expect_error(f("Test 1" = 1 == 2, "Test 2" = 2 == 3), "Test 1") expect_error(f("Test 1" = 1 == 1, "Test 2" = 2 == 3), "Test 2") expect_silent(f("Test 1" = 1 == 1, "Test 2" = 2 == 2)) backports/tests/test_dir.exists.R0000644000176200001440000000043614402606025016664 0ustar liggesuserssource("helper/helper.R") if (exists("dir.exists", envir = baseenv())) { f = get("dir.exists", envir = baseenv()) expect_same = makeCompareFun(f, backports:::dir.exists) expect_same(tempdir()) expect_same(tempfile()) expect_same(rep.int(tempdir(), 2)) expect_same(TRUE) } backports/tests/test_dotsLength.R0000644000176200001440000000101614402606025016676 0ustar liggesuserssource("helper/helper.R") wb = function(...) backports:::...length() if (exists("...length", envir = baseenv())) { f = get("...length", envir = baseenv()) wf = function(...) f() expect_same = makeCompareFun(wf, wb) expect_same(1) expect_same(1, 2) expect_same() } expect_identical(wb(1, "a", "b", "c"), 4L) expect_identical(wb(2, "a", "b"), 3L) expect_identical(wb(1), 1L) expect_identical(wb(), 0L) f = function(n) backports:::...length() expect_error(f(), "current call") expect_error(f(1), "current call") backports/tests/test_list2DF.R0000644000176200001440000000056714402606025016044 0ustar liggesuserssource("helper/helper.R") if (exists("list2DF", envir = baseenv())) { f = get("list2DF", envir = baseenv()) expect_same = makeCompareFun(f, backports:::list2DF) x <- list(c("A", "B"), c("B", "C")) n <- lengths(x) expect_same(list(x = x, n = n)) ## Create data frames with no variables and the desired number of rows: expect_same() expect_same(nrow = 3L) } backports/src/0000755000176200001440000000000014623627351013042 5ustar liggesusersbackports/src/init.c0000644000176200001440000000105314402606025014136 0ustar liggesusers#include #include #include // for NULL #include /* .Call calls */ extern SEXP dotsElt(SEXP, SEXP); extern SEXP dotsLength(SEXP); extern SEXP dotsNames(SEXP); static const R_CallMethodDef CallEntries[] = { {"dotsElt", (DL_FUNC) &dotsElt, 2}, {"dotsLength", (DL_FUNC) &dotsLength, 1}, {"dotsNames", (DL_FUNC) &dotsNames, 1}, {NULL, NULL, 0} }; void R_init_backports(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } backports/src/dotsElt.c0000644000176200001440000000077514402606025014623 0ustar liggesusers#include #include SEXP dotsElt(SEXP env_, SEXP i_) { SEXP ddd = findVar(R_DotsSymbol, env_); int i = INTEGER(i_)[0]; R_len_t n = length(ddd); if (ddd == R_UnboundValue) error("incorrect context: the current call has no '...' to look in"); if (i <= 0) error("indexing '...' with non-positive index %d", i); if (i > n) error("the ... list does not contain %d elements", i); ddd = nthcdr(ddd, i - 1); return eval(CAR(ddd), env_); } backports/src/dotsLength.c0000644000176200001440000000044314402606025015310 0ustar liggesusers#include #include SEXP dotsLength(SEXP env_) { SEXP ddd = findVar(R_DotsSymbol, env_); if (ddd == R_UnboundValue) error("incorrect context: the current call has no '...' to look in"); return ScalarInteger(TYPEOF(ddd) == DOTSXP ? length(ddd) : 0); } backports/src/dotsNames.c0000644000176200001440000000147014402606025015133 0ustar liggesusers#include #include #define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0) SEXP dotsNames(SEXP env) { SEXP vl = findVar(R_DotsSymbol, env); PROTECT(vl); if (vl == R_UnboundValue) error("incorrect context: the current call has no '...' to look in"); // else SEXP out; int n = length_DOTS(vl); Rboolean named = FALSE; for(int i = 0; i < n; i++) { if(TAG(vl) != R_NilValue) { if(!named) { named = TRUE; PROTECT(out = allocVector(STRSXP, n)); // and is filled with "" already } SET_STRING_ELT(out, i, PRINTNAME(TAG(vl))); } vl = CDR(vl); } if(named) { UNPROTECT(1); } else { out = R_NilValue; } UNPROTECT(1); return out; } #undef length_DOTS backports/R/0000755000176200001440000000000014623360347012453 5ustar liggesusersbackports/R/file.mode.R0000644000176200001440000000024514402606025014430 0ustar liggesusers#' @rdname file.size #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(file.mode) file.mode = function(...) { base::file.info(...)$mode } backports/R/startsWith.R0000644000176200001440000000121514402606025014740 0ustar liggesusers#' @title Backport of startsWith for R < 3.3.0 #' @rdname startsWith #' #' @description #' See the original description in \code{base::startsWith}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.3.0") export(startsWith) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_startsWith = getFromNamespace("startsWith", "backports") #' #' bp_startsWith(c("aabb", "bbcc"), "bb") startsWith = function(x, prefix) { if (!is.character(x) || !is.character(prefix)) stop("non-character object(s)") suppressWarnings(substr(x, 1L, nchar(prefix)) == prefix) } backports/R/valid.factor.R0000644000176200001440000000132314402606025015140 0ustar liggesusers#' @title Backport of .valid.factor for R < 3.4.0 #' @rdname valid.factor #' #' @description #' See the original description in \code{base::.valid.factor}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.4.0") export(.valid.factor) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_.valid_factor = getFromNamespace(".valid.factor", "backports") #' bp_.valid_factor(factor(letters[1:3])) .valid.factor = function (object) { levs <- levels(object) if (!is.character(levs)) return("factor levels must be \"character\"") if (d <- anyDuplicated(levs)) return(sprintf("duplicated level [%d] in factor", d)) TRUE } backports/R/vignetteInfo.R0000644000176200001440000000073714402606025015235 0ustar liggesusers#' @title Backport of vignetteInfo for R < 3.6.0 #' #' @description #' See the original description in \code{tools::vignetteInfo}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(vignetteInfo) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_vignetteInfo = getFromNamespace("vignetteInfo", "backports") vignetteInfo <- getFromNamespace("vignetteInfo", ns = "tools") backports/R/zzz.R0000644000176200001440000000030014623357054013425 0ustar liggesusers#' @importFrom utils getFromNamespace head "_PACKAGE" .onUnload = function (libpath) { library.dynam.unload("backports", libpath) environment(.libPaths) <- environment(base::.libPaths) } backports/R/paste.R0000644000176200001440000000141514402606025013702 0ustar liggesusers#' @title Backport of paste for R < 4.0.1 #' @rdname paste #' #' @description #' See the original description in \code{base::paste}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.1") export(paste) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_paste = getFromNamespace("paste", "backports") #' bp_paste(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) paste <- function(..., sep = " ", collapse = NULL, recycle0 = FALSE) { if(recycle0 && any(lengths(list(...)) == 0L)) { base::paste(sep = sep, collapse = collapse) # for argument checking if (is.null(collapse)) character() else "" } else { base::paste(..., sep = sep, collapse = collapse) } } backports/R/URLencode.R0000644000176200001440000000207414402606025014410 0ustar liggesusers#' @title Backport of URLencode for R < 3.2.0 #' @rdname URLencode #' #' @description #' See the original description in \code{utils::URLencode}. #' Argument \code{repeated} is backported. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(URLencode) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_URLencode = getFromNamespace("URLencode", "backports") #' #' URLdecode(z <- "ab%20cd") #' c(bp_URLencode(z), bp_URLencode(z, repeated = TRUE)) URLencode = function(URL, reserved = FALSE, repeated = FALSE) { if (!repeated && grepl("%[[:xdigit:]]{2}", URL, useBytes = TRUE)) return(URL) OK <- paste0( "[^", if (!reserved) "][!$&'()*+,;=:/?@#", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz0123456789._~-", "]" ) x <- strsplit(URL, "")[[1L]] z <- grep(OK, x) if (length(z)) { y <- sapply(x[z], function(x) paste0("%", toupper(as.character(charToRaw(x))), collapse = "")) x[z] <- y } paste(x, collapse = "") } backports/R/isFALSE.R0000644000176200001440000000102514402606025013751 0ustar liggesusers#' @title Backport of isFALSE for R < 3.4.2 #' @rdname isFALSE #' #' @description #' See the original description in \code{base::isFALSE}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.5.0") export(isFALSE) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_isFALSE = getFromNamespace("isFALSE", "backports") #' #' bp_isFALSE(FALSE) #' bp_isFALSE(iris) isFALSE = function(x) { is.logical(x) && length(x) == 1L && !is.na(x) && !x } backports/R/trimws.R0000644000176200001440000000145114402606025014113 0ustar liggesusers#' @title Backport of trimws for R < 3.3.0 #' @rdname trimws #' #' @description #' See the original description in \code{base::trimws}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(trimws) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_trimws = getFromNamespace("trimws", "backports") #' bp_trimws(c(" a ", "b ", " c")) #' #' bp_trimws(c(" a ", "b ", " c"), which = "left") trimws = function(x, which = c("both", "left", "right")) { which = match.arg(which) mysub = function(re, x) sub(re, "", x, perl = TRUE) if (which == "left") return(mysub("^[ \t\r\n]+", x)) if (which == "right") return(mysub("[ \t\r\n]+$", x)) mysub("[ \t\r\n]+$", mysub("^[ \t\r\n]+", x)) } backports/R/get0.R0000644000176200001440000000200014402606025013414 0ustar liggesusers#' @title Backport of get0 for R < 3.2.0 #' @rdname get0 #' #' @description #' See the original description in \code{base::get0}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(get0) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_get0 = getFromNamespace("get0", "backports") #' #' bp_get0("a") #' bp_get0("a", ifnotfound = 0) #' #' foo = 12 #' bp_get0("foo") get0 = function(x, envir = pos.to.env(-1L), mode = "any", inherits = TRUE, ifnotfound = NULL) { if (!is.character(x) || length(x) == 0L) { stop("Invalid first argument") } if (length(x) > 1L && getRversion() >= "4.1.0") { # this check was introduced in R-4.1.0 # We can remove the version check as soon as all CRAN packages have been updated, # i.e. as soon as 4.1.0 is released stop("first argument has length > 1") } mget(x[1L], envir = envir, mode = mode, inherits = inherits, ifnotfound = list(ifnotfound))[[1L]] } backports/R/removeSource.R0000644000176200001440000000222314402606025015242 0ustar liggesusers#' @title Backport of removeSource for R < 3.6.0 #' @rdname removeSource #' #' @description #' See the original description in \code{utils::removeSource}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(removeSource) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_removeSource = getFromNamespace("removeSource", "backports") #' #' bp_removeSource(mean) removeSource = function (fn) { recurse <- function(part) { if (is.name(part)) return(part) attr(part, "srcref") <- NULL attr(part, "wholeSrcref") <- NULL attr(part, "srcfile") <- NULL if (is.language(part) && is.recursive(part)) { for (i in seq_along(part)) part[i] <- list(recurse(part[[i]])) } part } if (is.function(fn)) { if (!is.primitive(fn)) { attr(fn, "srcref") <- NULL attr(body(fn), "wholeSrcref") <- NULL attr(body(fn), "srcfile") <- NULL body(fn) <- recurse(body(fn)) } fn } else if (is.language(fn)) { recurse(fn) } else { stop("argument is not a function or language object:", typeof(fn)) } } backports/R/R_user_dir.R0000644000176200001440000000402214402606025014660 0ustar liggesusers#' @title Backport of R_user_dir for R < 4.0.0 #' #' @description #' See the original description in \code{tools::R_user_dir}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.0") export(R_user_dir) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_R_user_dir = getFromNamespace("R_user_dir", "backports") #' #' bp_R_user_dir("backports") R_user_dir <- function(package, which = c("data", "config", "cache")) { stopifnot(is.character(package), length(package) == 1L) which <- match.arg(which) home <- normalizePath("~") path <- switch(which, data = { if(nzchar(p <- Sys.getenv("R_USER_DATA_DIR"))) p else if(nzchar(p <- Sys.getenv("XDG_DATA_HOME"))) p else if(.Platform$OS.type == "windows") file.path(Sys.getenv("APPDATA"), "R", "data") else if(Sys.info()["sysname"] == "Darwin") file.path(home, "Library", "Application Support", "org.R-project.R") else file.path(home, ".local", "share") }, config = { if(nzchar(p <- Sys.getenv("R_USER_CONFIG_DIR"))) p else if(nzchar(p <- Sys.getenv("XDG_CONFIG_HOME"))) p else if(.Platform$OS.type == "windows") file.path(Sys.getenv("APPDATA"), "R", "config") else if(Sys.info()["sysname"] == "Darwin") file.path(home, "Library", "Preferences", "org.R-project.R") else file.path(home, ".config") }, cache = { if(nzchar(p <- Sys.getenv("R_USER_CACHE_DIR"))) p else if(nzchar(p <- Sys.getenv("XDG_CACHE_HOME"))) p else if(.Platform$OS.type == "windows") file.path(Sys.getenv("LOCALAPPDATA"), "R", "cache") else if(Sys.info()["sysname"] == "Darwin") file.path(home, "Library", "Caches", "org.R-project.R") else file.path(home, ".cache") }) file.path(path, "R", package) } backports/R/dotsLength.R0000644000176200001440000000110114402606025014671 0ustar liggesusers#' @title Backport of ...length for R < 3.4.2 #' @rdname dotsLength #' #' @description #' See the original description in \code{base::...length}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.5.0") export(...length) #' @useDynLib backports dotsLength #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_...length = getFromNamespace("...length", "backports") #' #' foo = function(...) bp_...length() #' foo(1, 2, 3) ...length = function() { .Call(dotsLength, parent.frame()) } backports/R/strrep.R0000644000176200001440000000141014402606025014100 0ustar liggesusers#' @title Backport of strrep for R < 3.3.0 #' @rdname strrep #' #' @description #' See the original description in \code{base::strrep}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.3.0") export(strrep) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_strrep = getFromNamespace("strrep", "backports") #' #' bp_strrep("-", 10) strrep = function(x, times) { x = as.character(x) if (length(x) == 0L) return(x) unlist(.mapply(function(x, times) { if (is.na(x) || is.na(times)) return(NA_character_) if (times <= 0L) return("") paste0(replicate(times, x), collapse = "") }, list(x = x, times = times), MoreArgs = list()), use.names = FALSE) } backports/R/libPaths.R0000644000176200001440000000223214402606025014332 0ustar liggesusers#' @title Backport of .libPaths for R < 4.1.0 #' @rdname libPaths #' #' @description #' See the original description in \code{base::.libPaths}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.1.0") export(.libPaths) #' @examples #' save <- .libPaths() #' save #' # ignore the site library #' .libPaths("test", include.site = FALSE) #' #' # restore the original #' .libPaths(save) .libPaths <- local({ .lib.loc <- character() # This won't be used; see below function(new, include.site = TRUE) { if(!missing(new)) { ## paths don't really need to be unique, but searching ## large library trees repeatedly would be inefficient. ## Use normalizePath for display new <- Sys.glob(path.expand(new)) paths <- c(new, if(include.site) .Library.site, .Library) paths <- paths[dir.exists(paths)] .lib.loc <<- unique(normalizePath(paths, "/")) } else .lib.loc }}) # Run this in .onLoad: # environment(.libPaths) <- environment(base::.libPaths) # This will make our function see and modify the base # function's copy of .lib.loc. This relies on the # implementation in base, which has been the # same since R 1.6.0 or earlier. backports/R/isTRUE.R0000644000176200001440000000130214402606025013674 0ustar liggesusers#' @title Backport of isTRUE for R < 3.5.0 #' @rdname isTRUE #' #' @description #' The implementation of `isTRUE` has been changed in R-3.5.0 from #' \code{identical(x, TRUE)} to \code{is.logical(x) && length(x) == 1L && !is.na(x) && x}. #' This backport overloads the old implementation for R versions prior to 3.5.0. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.5.0") export(isTRUE) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_isTRUE = getFromNamespace("isTRUE", "backports") #' #' bp_isTRUE(FALSE) #' bp_isTRUE(iris) isTRUE = function(x) { is.logical(x) && length(x) == 1L && !is.na(x) && x } backports/R/isNamespaceLoaded.R0000644000176200001440000000110314402606025016121 0ustar liggesusers#' @title Backport of isNamespaceLoaded for R < 3.2.0 #' @rdname isNamespaceLoaded #' #' @description #' See the original description in \code{base::isNamespaceLoaded}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(isNamespaceLoaded) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_isNamespaceLoaded = getFromNamespace("isNamespaceLoaded", "backports") #' #' bp_isNamespaceLoaded("backports") isNamespaceLoaded = function(name) { name %in% loadedNamespaces() } backports/R/endsWith.R0000644000176200001440000000122414402606025014351 0ustar liggesusers#' @title Backport of endsWith for R < 3.3.0 #' @rdname endsWith #' #' @description #' See the original description in \code{base::endsWith}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.3.0") export(endsWith) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_endsWith = getFromNamespace("endsWith", "backports") #' #' bp_endsWith(c("aabb", "bbcc"), "bb") endsWith = function(x, suffix) { if (!is.character(x) || !is.character(suffix)) stop("non-character object(s)") n = nchar(x) suppressWarnings(substr(x, n - nchar(suffix) + 1L, n) == suffix) } backports/R/file.mtime.R0000644000176200001440000000025014402606025014613 0ustar liggesusers#' @rdname file.size #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(file.mtime) file.mtime = function(...) { base::file.info(...)$mtime } backports/R/file.info.R0000644000176200001440000000125314402606025014437 0ustar liggesusers#' @title Backport of \code{file.info} for R < 3.2.0 #' #' @description #' Argument \code{extra_cols} has been backported. #' See the original description in \code{base::file.info}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(file.info) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_file.info = getFromNamespace("file.info", "backports") #' #' bp_file.info(file.path(R.home(), "COPYING"), extra_cols = FALSE) file.info = function (..., extra_cols = TRUE) { if (isTRUE(extra_cols)) base::file.info(...) else base::file.info(...)[, 1:6, drop = FALSE] } backports/R/list2DF.R0000644000176200001440000000226414402606025014040 0ustar liggesusers#' @title Backport of list2DF for R < 4.0.0 #' @rdname list2DF #' #' @description #' See the original description in \code{base::list2DF}. #' Note that the behaviour of \code{list2DF()} changed in #' R 4.2.0. Instead of recycling vectors to common length, an #' exception is raised. #' This backport implements the new behaviour, #' throwing an error message. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.0") export(list2DF) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_list2DF = getFromNamespace("list2DF", "backports") #' #' bp_list2DF(list(x = 1:3, y = 2:4)) list2DF <- function(x = list(), nrow = 0L) { stopifnot(is.list(x), is.null(nrow) || nrow >= 0L) if (n <- length(x)) { if (length(nrow <- unique(lengths(x))) > 1L) stop("all variables should have the same length") } else { if (is.null(nrow)) nrow <- 0L } if (is.null(names(x))) names(x) <- character(n) class(x) <- "data.frame" attr(x, "row.names") <- .set_row_names(nrow) x } .set_row_names = function (n) if (n > 0) c(NA_integer_, -n) else integer() backports/R/file.size.R0000644000176200001440000000133214402606025014454 0ustar liggesusers#' @title Backports of wrappers around \code{file.info} for R < 3.2.0 #' @rdname file.size #' #' @description #' See the original description in \code{base::file.size}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(file.size) #' @examples #' # get functions from namespace instead of possibly getting #' # implementations shipped with recent R versions: #' bp_file.size = getFromNamespace("file.size", "backports") #' bp_file.mode = getFromNamespace("file.size", "backports") #' bp_file.mtime = getFromNamespace("file.size", "backports") #' #' fn = file.path(R.home(), "COPYING") #' bp_file.size(fn) #' bp_file.mode(fn) #' bp_file.size(fn) file.size = function(...) { base::file.info(...)$size } backports/R/Rconcordance.R0000644000176200001440000001574214402606025015176 0ustar liggesusers# These functions are taken from the R sources. # The original copyright notice was as follows: ## Copyright (C) 1995-2016 The R Core Team ## Copyright (C) 2022 Duncan Murdoch ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 2 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## A copy of the GNU General Public License is available at ## https://www.R-project.org/Licenses/ #' @title Backport of print.Rconcordance for R < 4.3.0 #' #' @description #' See the original description in \code{tools::print.Rconcordance}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.3.0") S3method("print", "Rconcordance") print.Rconcordance <- function(x, ...) { df <- data.frame(srcFile = x$srcFile, srcLine = x$srcLine) rownames(df) <- seq_len(nrow(df)) + x$offset print(df) invisible(x) } # This function converts concordance objects to string representations # of them. ## The string has three or four parts, separated by colons: ## 1. The output .tex filename ## 2. The input .Rnw filename ## 3. Optionally, the starting line number of the output coded as "ofs nn", ## where nn is the offset to the first output line. This is omitted if nn is 0. ## 4. The input line numbers corresponding to each output line. ## This are compressed using the following simple scheme: ## The first line number, followed by ## a run-length encoded diff of the rest of the line numbers. #' @title Backport of as.character.Rconcordance for R < 4.3.0 #' #' @description #' See the original description in \code{tools::as.character.Rconcordance}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.3.0") S3method("as.character", "Rconcordance") as.character.Rconcordance <- function(x, targetfile = "", ...) { concordance <- x offset <- concordance$offset src <- concordance$srcLine result <- character() srcfile <- rep_len(concordance$srcFile, length(src)) while (length(src)) { first <- src[1] if (length(unique(srcfile)) > 1) n <- which(srcfile != srcfile[1])[1] - 1 else n <- length(srcfile) vals <- with(rle(diff(src[seq_len(n)])), as.numeric(rbind(lengths, values))) result <- c(result, paste0("concordance:", targetfile, ":", srcfile[1], ":", if (offset) paste0("ofs ", offset, ":"), concordance$srcLine[1], " ", paste(vals, collapse = " ") )) offset <- offset + n drop <- seq_len(n) src <- src[-drop] srcfile <- srcfile[-drop] } result } #' @title Backport of as.Rconcordance for R < 4.3.0 #' #' @description #' See the original description in \code{tools::as.Rconcordance}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.3.0") export(as.Rconcordance) as.Rconcordance <- function(x, ...) { UseMethod("as.Rconcordance") } #' @title Backport of as.Rconcordance.default for R < 4.3.0 #' #' @description #' See the original description in \code{tools::as.Rconcordance}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.3.0") S3method("as.Rconcordance", "default") as.Rconcordance.default <- function(x, ...) { # clean comments etc. s <- sub("^.*(concordance){1}?", "concordance", sub("[^[:digit:]]*$", "", x)) s <- grep("^concordance:", s, value = TRUE) if (!length(s)) return(NULL) result <- stringToConcordance(s[1]) for (line in s[-1]) result <- addConcordance(result, line) result } # This takes one concordance string and produces a single concordance # object stringToConcordance <- function(s) { split <- strsplit(s, ":")[[1]] targetfile <- split[2] srcFile <- split[3] if (length(split) == 4) { ofs <- 0 vi <- 4 } else { ofs <- as.integer(sub("^ofs ([0-9]+)", "\\1", split[4])) vi <- 5 } values <- as.integer(strsplit(split[vi], " ")[[1]]) firstline <- values[1] rledata <- matrix(values[-1], nrow = 2) rle <- structure(list(lengths=rledata[1,], values=rledata[2,]), class="rle") diffs <- inverse.rle(rle) srcLines <- c(firstline, firstline + cumsum(diffs)) structure(list(offset = ofs, srcFile = srcFile, srcLine = srcLines), class = "Rconcordance") } # This modifies an existing concordance object to incorporate # one new concordance string addConcordance <- function(conc, s) { prev <- stringToConcordance(s) if (!is.null(prev)) { conc$srcFile <- rep_len(conc$srcFile, length(conc$srcLine)) i <- seq_along(prev$srcLine) conc$srcFile[prev$offset + i] <- prev$srcFile conc$srcLine[prev$offset + i] <- prev$srcLine } conc } # This modifies an existing concordance by following links specified # in a previous one. followConcordance <- function(conc, prevConcordance) { if (!is.null(prevConcordance)) { curLines <- conc$srcLine curFile <- rep_len(conc$srcFile, length(curLines)) curOfs <- conc$offset prevLines <- prevConcordance$srcLine prevFile <- rep_len(prevConcordance$srcFile, length(prevLines)) prevOfs <- prevConcordance$offset if (prevOfs) { prevLines <- c(rep(NA_integer_, prevOfs), prevLines) prevFile <- c(rep(NA_character_, prevOfs), prevFile) prevOfs <- 0 } n0 <- max(curLines) n1 <- length(prevLines) if (n1 < n0) { prevLines <- c(prevLines, rep(NA_integer_, n0 - n1)) prevFile <- c(prevFile, rep(NA_character_, n0 - n1)) } new <- is.na(prevLines[curLines]) conc$srcFile <- ifelse(new, curFile, prevFile[curLines]) conc$srcLine <- ifelse(new, curLines, prevLines[curLines]) } conc } #' @title Backport of matchConcordance for R < 4.3.0 #' #' @description #' See the original description in \code{tools::matchConcordance}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.3.0") export(matchConcordance) matchConcordance <- function(linenum, concordance) { if (!all(c("offset", "srcLine", "srcFile") %in% names(concordance))) stop("concordance is not valid") linenum <- as.numeric(linenum) srcLines <- concordance$srcLine srcFile <- rep_len(concordance$srcFile, length(srcLines)) offset <- concordance$offset result <- matrix(character(), length(linenum), 2, dimnames = list(NULL, c("srcFile", "srcLine"))) for (i in seq_along(linenum)) { if (linenum[i] <= concordance$offset) result[i,] <- c("", "") else result[i,] <- c(srcFile[linenum[i] - offset], with(concordance, srcLine[linenum[i] - offset])) } result } backports/R/null_coalesce.R0000644000176200001440000000116514623357543015415 0ustar liggesusers#' @title Backport of the null-coalescing operator for R < 4.4.0 #' @name null_coalesce_operator #' @rdname null_coalesce_operator #' #' @usage x \%||\% y #' #' @description #' See the original description in \code{Control}. #' #' @param x (any). #' @param y (any). #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.4.0") export(`%||%`) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_null_coalesce = getFromNamespace("%||%", "backports") #' #' bp_null_coalesce(NULL, FALSE) "%||%" = function(x, y) { if (is.null(x)) y else x } backports/R/dotsNames.R0000644000176200001440000000107714402606025014527 0ustar liggesusers#' @title Backport of ...names for R < 4.1.0 #' @rdname dotsNames #' #' @description #' See the original description in \code{base::...names}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.1.0") export(...names) #' @useDynLib backports dotsNames #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_...names = getFromNamespace("...names", "backports") #' #' foo = function(...) bp_...names() #' foo(a = 1, b = 2, 3) ...names = function() { .Call(dotsNames, parent.frame()) } backports/R/hasName.R0000644000176200001440000000103414402606025014137 0ustar liggesusers#' @title Backport of hasName for R < 3.4.0 #' @rdname hasName #' #' @description #' See the original description in \code{utils::hasName}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.4.0") export(hasName) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_hasName = getFromNamespace("hasName", "backports") #' #' bp_hasName(list(a = 1, b = 2), c("a", "b", "c")) hasName = function(x, name) { match(name, names(x), nomatch = 0L) > 0L } backports/R/lengths.R0000644000176200001440000000111714402606025014231 0ustar liggesusers#' @title Backport of lengths for R < 3.2.0 #' @rdname lengths #' #' @description #' See the original description in \code{base::lengths}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(lengths) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_lengths = getFromNamespace("lengths", "backports") #' #' bp_lengths(list(1:3, 2)) lengths = function(x, use.names = TRUE) { ans <- sapply(x, length, USE.NAMES = FALSE) if (!isTRUE(use.names)) { names(ans) <- NULL } ans } backports/R/stopifnot.R0000644000176200001440000000526214402606025014617 0ustar liggesusers#' @title Backport of stopifnot for R versions < 4.0.0. #' #' @description #' See the original description in \code{base::stopifnot}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.0") export(stopifnot) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_stopifnot = getFromNamespace("stopifnot", "backports") #' #' m <- matrix(c(1, 3, 12, 1), 2, 2) #' \dontrun{bp_stopifnot("m must be symmetric" = m == t(m))} stopifnot = function(..., exprs, exprObject, local = TRUE) { n <- ...length() if ((has.e <- !missing(exprs)) || !missing(exprObject)) { if (n || (has.e && !missing(exprObject))) stop("Only one of 'exprs', 'exprObject' or expressions, not more") envir <- if (isTRUE(local)) parent.frame() else if (isFALSE(local)) .GlobalEnv else if (is.environment(local)) local else stop("'local' must be TRUE, FALSE or an environment") E1 <- if (has.e && is.call(exprs <- substitute(exprs))) exprs[[1]] cl <- if (is.symbol(E1) && E1 == quote(`{`)) { exprs[[1]] <- quote(stopifnot) ## --> stopifnot(*, *, ..., *) : exprs } else as.call(c(quote(stopifnot), if (!has.e) exprObject else as.expression(exprs))) # or fail .. names(cl) <- NULL return(eval(cl, envir = envir)) } ## else use '...' (and not 'exprs') : Dparse <- function(call, cutoff = 60L) { ch <- deparse(call, width.cutoff = cutoff) if (length(ch) > 1L) paste(ch[1L], "....") else ch } head <- function(x, n = 6L) ## basically utils:::head.default() x[seq_len(if (n < 0L) max(length(x) + n, 0L) else min(n, length(x)))] abbrev <- function(ae, n = 3L) paste(c(head(ae, n), if (length(ae) > n) "...."), collapse = "\n ") ## for (i in seq_len(n)) { r <- ...elt(i) if (!(is.logical(r) && !anyNA(r) && all(r))) { dots <- match.call()[-1L] if (is.null(msg <- names(dots)) || !nzchar(msg <- msg[i])) { cl.i <- dots[[i]] msg <- ## special case for decently written 'all.equal(*)': if (is.call(cl.i) && identical(cl.i[[1]], quote(all.equal)) && (is.null(ni <- names(cl.i)) || length(cl.i) == 3L || length(cl.i <- cl.i[!nzchar(ni)]) == 3L)) sprintf(gettext("%s and %s are not equal:\n %s"), Dparse(cl.i[[2]]), Dparse(cl.i[[3]]), abbrev(r)) else sprintf(ngettext(length(r), "%s is not TRUE", "%s are not all TRUE"), Dparse(cl.i)) } stop(simpleError(msg, call = if (p <- sys.parent(1L)) sys.call(p))) } } invisible() } backports/R/warningCondition.R0000644000176200001440000000174014402606025016103 0ustar liggesusers#' @title Backport of warningCondition and errorCondition for R < 3.6.0 #' @rdname warningCondition #' #' @description #' See the original description in \code{base::warningCondition}/\code{base::errorCondition}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(warningCondition) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_warningCondition = getFromNamespace("warningCondition", "backports") #' bp_warningCondition("package backports not found") warningCondition <- function(msg, ..., class = NULL, call = NULL) { structure(list(message = msg, call = call, ...), class = c(class, "warning", "condition")) } #' @rdname warningCondition #' @rawNamespace if (getRversion() < "3.6.0") export(errorCondition) errorCondition <- function(msg, ..., class = NULL, call = NULL) { structure(list(message = msg, call = call, ...), class = c(class, "error", "condition")) } backports/R/anyNA.R0000644000176200001440000000113114402606025013567 0ustar liggesusers#' @title Backport of anyNA for R versions < 3.2.0. #' #' @description #' See the original description in \code{base::anyNA}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(anyNA) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_anyNA = getFromNamespace("anyNA", "backports") #' #' bp_anyNA(letters) anyNA = function(x, recursive = FALSE) { if (isTRUE(recursive) && (is.list(x) || is.pairlist(x))) return(any(rapply(x, anyNA, how = "unlist", recursive = FALSE))) any(is.na(x)) } backports/R/deparse1.R0000644000176200001440000000111314402606025014265 0ustar liggesusers#' @title Backport of deparse1 for R < 4.0.0 #' @rdname deparse1 #' #' @description #' See the original description in \code{base::deparse1}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.0") export(deparse1) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_deparse1 = getFromNamespace("deparse1", "backports") #' #' bp_deparse1(quote(`foo bar`)) deparse1 = function (expr, collapse = " ", width.cutoff = 500L, ...) { paste(deparse(expr, width.cutoff, ...), collapse = collapse) } backports/R/str2lang.R0000644000176200001440000000111414402606025014316 0ustar liggesusers#' @title Backport of str2lang for R < 3.6.0 #' @rdname str2lang #' #' @description #' See the original description in \code{base::str2lang}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(str2lang) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' str2lang <- getFromNamespace("str2lang", "backports") #' #' str2lang("x[3] <- 1+4") str2lang <- function(s) { stopifnot(length(s) == 1L) ex <- parse(text=s, keep.source=FALSE) stopifnot(length(ex) == 1L) ex[[1L]] } backports/R/import.R0000644000176200001440000000545114623360347014115 0ustar liggesusers#' @title Import backported functions into your package #' #' @description #' Imports objects from \pkg{backports} into the namespace of other packages #' by assigning it during load-time. #' See examples for a code snippet to copy to your package. #' #' @param pkgname [\code{character(1)}]\cr #' Name of the package where the backported function should be assigned. #' @param obj [\code{character}]\cr #' Name of objects to assign, as character vector. #' If \code{NULL}, all backports which are not provided by R itself are assigned. #' @param force [\code{logical}]\cr #' If \code{obj} is provided and \code{force} is set to \code{FALSE}, only backports #' not provided by the base package of the executing R interpreter are imported. #' Set to \code{TRUE} to ignore this check and always import the backport into the package's namespace. #' @export #' @seealso \code{\link{.onLoad}} #' @examples #' \dontrun{ #' # This imports all functions implemented in backports while the package is loaded #' .onLoad <- function(libname, pkgname) { #' backports::import(pkgname) #' } #' #' # This only imports the function "trimws" #' .onLoad <- function(libname, pkgname) { #' backports::import(pkgname, "trimws") #' } #' #' # This imports all backports from base and force-imports "hasName" from utils #' .onLoad <- function(libname, pkgname) { #' backports::import(pkgname) #' backports::import(pkgname, "hasName", force = TRUE) #' } #' } import = function(pkgname, obj = NULL, force = FALSE) { if (is.null(obj)) { obj = get_backports() } else if (!isTRUE(force)) { obj = intersect(obj, get_backports()) } if (length(obj) > 0L) { pkg = getNamespace(pkgname) backports = getNamespace("backports") for (x in obj) { assign(x, get(x, envir = backports), envir = pkg) } } invisible(TRUE) } get_backports = function(v = getRversion()) { v = package_version(v) nn = names(FUNS) for (i in seq_along(FUNS)) { if (v >= nn[i]) break } unlist(head(FUNS, i - 1L), use.names = FALSE) } FUNS = list( "4.4.0" = "%||%", "4.3.0" = c("as.Rconcordance", "matchConcordance"), "4.1.0" = c("...names", ".libPaths"), "4.0.1" = c("paste", "paste0"), "4.0.0" = c("R_user_dir", "deparse1", "list2DF", "suppressWarnings", "suppressMessages", "stopifnot"), "3.6.0" = c("warningCondition", "errorCondition", "vignetteInfo", "dQuote", "sQuote", "removeSource", "asplit", "str2lang", "str2expression"), "3.5.0" = c("...length", "...elt", "isFALSE", "isTRUE"), "3.4.0" = c("hasName", ".valid.factor"), "3.3.0" = c("startsWith", "endsWith", "strrep", "capture.output"), "3.2.0" = c("anyNA", "dir.exists", "file.size", "file.mode", "file.mtime", "lengths", "file.info", "URLencode", "isNamespaceLoaded", "trimws"), "3.1.0" = character(), "3.0.0" = character(), "0.0.0" = character() ) backports/R/asplit.R0000644000176200001440000000255514402606025014070 0ustar liggesusers#' @title Backport of asplit for R < 3.6.0 #' @rdname asplit #' #' @description #' See the original description in \code{base::asplit}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(asplit) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_asplit = getFromNamespace("asplit", "backports") #' x = matrix(1:6, 2, 3) #' bp_asplit(x, 1) asplit = function (x, MARGIN) { dl <- length(dim(x)) if (!dl) stop("dim(x) must have a positive length") if (is.object(x)) x <- if (dl == 2L) as.matrix(x) else as.array(x) d <- dim(x) dn <- dimnames(x) ds <- seq_len(dl) if (is.character(MARGIN)) { if (is.null(dnn <- names(dn))) stop("'x' must have named dimnames") MARGIN <- match(MARGIN, dnn) if (anyNA(MARGIN)) stop("not all elements of 'MARGIN' are names of dimensions") } s.call <- ds[-MARGIN] s.ans <- ds[MARGIN] d.call <- d[-MARGIN] d.ans <- d[MARGIN] dn.call <- dn[-MARGIN] dn.ans <- dn[MARGIN] d2 <- prod(d.ans) newx <- aperm(x, c(s.call, s.ans)) dim(newx) <- c(prod(d.call), d2) ans <- vector("list", d2) for (i in seq_len(d2)) { ans[[i]] <- array(newx[, i], d.call, dn.call) } array(ans, d.ans, dn.ans) } backports/R/dotsElt.R0000644000176200001440000000110414402606025014177 0ustar liggesusers#' @title Backport of ...elt for R < 3.4.2 #' @rdname dotsElt #' #' @description #' See the original description in \code{base::...elt}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.5.0") export(...elt) #' @useDynLib backports dotsElt #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_...elt = getFromNamespace("...elt", "backports") #' #' foo = function(n, ...) bp_...elt(n) #' foo(n = 2, "a", "b", "c") ...elt = function(n) { .Call(dotsElt, parent.frame(), as.integer(n)) } backports/R/dQuote.R0000644000176200001440000000473314402606025014035 0ustar liggesusers#' @title Backport of dQuote and sQuote for R < 3.6.0 #' #' @description #' Argument \code{q} has been backported. #' See the original description in \code{base::dQuote()} and \code{base::sQuote()}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(dQuote) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_dQuote <- getFromNamespace("dQuote", "backports") #' bp_dQuote("foo") #' bp_dQuote("foo", q = TRUE) dQuote <- function(x, q = getOption("useFancyQuotes")) { if (!length(x)) return(character()) before <- after <- "\"" if(!is.null(q)) { if(isTRUE(q)) { li <- l10n_info() if(li$"UTF-8") q <- "UTF-8" if(!is.null(li$codepage) && li$codepage > 0L) { if(li$codepage >= 1250L && li$codepage <= 1258L || li$codepage == 874L) { before <- rawToChar(as.raw(0x93)) after <- rawToChar(as.raw(0x94)) } else { z <- iconv(c(intToUtf8(0x201c), intToUtf8(0x201d)), "UTF-8", "") before <- z[1L]; after <- z[2L] } } } if(identical(q, "TeX")) { before <- "``"; after <- "''" } if(identical(q, "UTF-8")) { before <- intToUtf8(0x201c); after <- intToUtf8(0x201d) } if(is.character(q) && length(q) >= 4L) { before <- q[3L]; after <- q[4L] } } paste0(before, x, after) } #' @rdname dQuote #' @rawNamespace if (getRversion() < "3.6.0") export(sQuote) sQuote <- function(x, q = getOption("useFancyQuotes")) { if (!length(x)) return(character()) before <- after <- "'" if(!is.null(q)) { if(isTRUE(q)) { li <- l10n_info() if(li$"UTF-8") q <- "UTF-8" if(!is.null(li$codepage) && li$codepage > 0L) { ## we can't just use iconv, as that seems to think ## it is in latin1 in CP1252 if(li$codepage >= 1250L && li$codepage <= 1258L || li$codepage == 874L) { before <- rawToChar(as.raw(0x91)) after <- rawToChar(as.raw(0x92)) } else { z <- iconv(c(intToUtf8(0x2018), intToUtf8(0x2019)), "UTF-8", "") before <- z[1L]; after <- z[2L] } } } if(identical(q, "TeX")) { before <- "`"; after <- "'" } if(identical(q, "UTF-8")) { before <- intToUtf8(0x2018); after <- intToUtf8(0x2019) } if(is.character(q) && length(q) >= 4L) { before <- q[1L]; after <- q[2L] } } paste0(before, x, after) } backports/R/str2expression.R0000644000176200001440000000105214402606025015575 0ustar liggesusers#' @title Backport of str2expression for R < 3.6.0 #' @rdname str2expression #' #' @description #' See the original description in \code{base::str2expression}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.6.0") export(str2expression) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' str2expression <- getFromNamespace("str2expression", "backports") #' #' str2expression("x[3] <- 1+4") str2expression <- function(text) parse(text=text, keep.source=FALSE) backports/R/capture.output.R0000644000176200001440000000346714402606025015601 0ustar liggesusers#' @title Backport of capture.output for R < 3.3.0 #' #' @description #' Argument \code{type} has been backported. #' See the original description in \code{utils::capture.output}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.3.0") export(capture.output) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_capture.output <- getFromNamespace("capture.output", "backports") #' #' captured <- bp_capture.output({ message("hi") }, type = "message") #' str(captured) capture.output <- function(..., file=NULL, append=FALSE, type = c("output", "message"), split = FALSE) { args <- substitute(list(...))[-1L] type <- match.arg(type) rval <- NULL; closeit <- TRUE if (is.null(file)) file <- textConnection("rval", "w", local = TRUE) else if (is.character(file)) file <- file(file, if(append) "a" else "w") else if (inherits(file, "connection")) { if (!isOpen(file)) open(file, if(append) "a" else "w") else closeit <- FALSE } else { stop("'file' must be NULL, a character string or a connection") } sink(file, type=type, split=split) ## for error recovery: all output will be lost if file=NULL on.exit({sink(type=type, split=split); if(closeit) close(file)}) pf <- parent.frame() evalVis <- function(expr) withVisible(eval(expr, pf)) for(i in seq_along(args)) { expr <- args[[i]] tmp <- switch(mode(expr), "expression" = lapply(expr, evalVis), "call" =, "name" = list(evalVis(expr)), stop("bad argument") ) for(item in tmp) if (item$visible) print(item$value) } ## we need to close the text connection before returning 'rval' on.exit() sink(type=type, split=split) if(closeit) close(file) if(is.null(rval)) invisible(NULL) else rval } backports/R/paste0.R0000644000176200001440000000113514402606025013761 0ustar liggesusers#' @title Backport of paste0 for R < 4.0.1 #' @rdname paste0 #' #' @description #' See the original description in \code{base::paste0}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.1") export(paste0) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_paste0 = getFromNamespace("paste0", "backports") #' bp_paste0(letters[1:3], character(), collapse = NULL, recycle0 = TRUE) paste0 <- function(..., collapse = NULL, recycle0 = FALSE) { paste(..., sep = "", collapse = collapse, recycle0 = recycle0) } backports/R/suppressWarnings.R0000644000176200001440000000236314402606025016166 0ustar liggesusers#' @title Backport of suppressWarnings and suppressMessages for R < 4.0.0 #' @rdname suppressWarnings #' #' @description #' Backport for new argument `classes`. #' See the original description in \code{base::suppressWarnings}/\code{base::suppressMessages}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "4.0.0") export(suppressWarnings) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_suppressWarnings = getFromNamespace("suppressWarnings", "backports") #' bp_suppressWarnings(warningCondition("warning", class = "testWarning"), "testWarning") suppressWarnings = function (expr, classes = "warning") { withCallingHandlers(expr, warning = function(w) if (inherits(w, classes)) tryInvokeRestart("muffleWarning") ) } #' @rdname suppressWarnings #' @rawNamespace if (getRversion() < "4.0.0") export(suppressMessages) suppressMessages = function (expr, classes = "message") { withCallingHandlers(expr, message = function(c) if (inherits(c, classes)) tryInvokeRestart("muffleMessage") ) } tryInvokeRestart = function (r, ...) { if (!isRestart(r)) r <- findRestart(r) if (is.null(r)) invisible(NULL) else invokeRestart(r, ...) } backports/R/dir.exists.R0000644000176200001440000000101014402606025014651 0ustar liggesusers#' @title Backport of dir.exists for R < 3.2.0 #' #' @description #' See the original description in \code{base::dir.exists}. #' #' @keywords internal #' @rawNamespace if (getRversion() < "3.2.0") export(dir.exists) #' @examples #' # get function from namespace instead of possibly getting #' # implementation shipped with recent R versions: #' bp_dir.exists = getFromNamespace("dir.exists", "backports") #' #' bp_dir.exists(tempdir()) dir.exists = function(paths) { x = base::file.info(paths)$isdir !is.na(x) & x } backports/NEWS.md0000644000176200001440000000677714623360507013367 0ustar liggesusers# backports 1.5.0 * Added backport for the null-coalesce operator `%||%` for R versions prior to 4.4.0. * `lengths()` now also works for long vectors (#64, thanks to @HughParsonage) # backports 1.4.1 * Patched `...names()` to match the new implementation in r-devel (svn rev 81283). # backports 1.4.0 * Added `paste()` with support for argument `recycle0` for R versions prior to 4.0.1. * Added `paste0()` with support for argument `recycle0` for R versions prior to 4.0.1. * Added backport for `...names()` for R versions prior to 4.1.0. # backports 1.3.0 * Added backport for `stopifnot()` for R versions prior to 4.0.0. * Adapted `list2DF()` to new behaviour introduced in r81038: the inputs are not recycled anymore to common length. Instead, an error is thrown. # backports 1.2.1 * Adapted `get0()` to work with R-devel / R-4.1.0 for first argument having length greater than 1. # backports 1.2.0 * Switched to semantic versioning. * Added backport for `asplit()` for R versions prior to 3.6.0 (#47). * Added backport for `removeSource()` which also supports language objects for R versions prior to 3.6.0 (#50). * Added backport for `isNamespaceLoaded` for R versions prior to 3.2.0 (#49). # backports 1.1.10 * Added `suppressMessages()` and `suppressWarnings()` with support for argument `classes` for R versions prior to 4.0.0 # backports 1.1.9 * Added backports for `str2lang()` and `str2expression()` (#42) Thanks to @dmurdoch. * `import()` imported too many functions and has been fixed. # backports 1.1.8 * Added backport for `tools::vignetteInfo()` for R versions prior to 3.6.0 * Fixed import of `list2DF()` and `deparse1()` # backports 1.1.7 * Added backport for `deparse1()` for R versions prior to 4.0.0. * Added backport for `list2DF()` for R versions prior to 4.0.0. # backports 1.1.6 * Added backport for `R_user_dir()` for R versions prior to 4.0.0. * Added `dQuote()` and `sQuote()` with support for argument `q` for R versions prior to 3.6.0. # backports 1.1.5 * Changed license from GPL-2 to GPL-2 or GPL-3. * Added backport for `isTRUE()` implementing the new behaviour introduced in R 3.5.0. # backports 1.1.4 * Fixed import of `warningCondition()` and `errorCondition()`. # backports 1.1.3 * Added `warningCondition()` and `errorCondition()` for R versions prior to 3.6.0. * Added `capture.output()` with support for argument `type` for R versions prior to 3.3.0. * Added `URLencode()` with support for argument `repeated` for R versions prior to 3.2.0. # backports 1.1.2 * Improved import mechanism. * Added `.valid.factor()` for R versions prior to 3.4.0. # backports 1.1.1 * Added `...length()` and `...elt()` for R versions prior to 3.5.0. * Added `isFALSE()` for R versions prior to 3.5.0. # backports 1.1.0 * New import mechanism to import packages during load-time with the function `import()`. This is now the recommended way to use backports non-interactively. Simply importing backports in the NAMESPACE still works, but is comparably error-prone if the same library is used by multiple R installations. # backports 1.0.5 * Added `get0()` for R versions prior to 3.2.0. * Added examples. # backports 1.0.4 * Added `hasName()` for R versions prior to 3.4.0. * Added `file.info()` with backport for argument `extra_cols`. # backports 1.0.3 * Removed stringi dependency. # backports 1.0.2 * Fixed `file.size()`, `file.mtime()` and `file.mode()` for R-3.1.x. # backports 1.0.1 * Added `file.size()`, `file.mtime()` and `file.mode()` for R versions prior to 3.2.0. # backports 1.0.0 * Initial version. backports/MD50000644000176200001440000001510014623633312012552 0ustar liggesusers830f063bb332aea2dac14e17f4a0b13f *DESCRIPTION 6187002963806292c9d8e1ec79b45896 *NAMESPACE b3953c15a7e0f5b2940008fb3a1a1a45 *NEWS.md 35c58f655ad5194e8af81d851c58e719 *R/R_user_dir.R 563ce2bc12c47b698b8fd1b390b27b90 *R/Rconcordance.R 6dee293e8cc80c13e777ee75195e03dc *R/URLencode.R 41879b295859b9f3dd0efc69737d4a12 *R/anyNA.R 9c183e8ddeee8fd103b5910ebabab872 *R/asplit.R 24d8b9d2ebd6ad91d6b37527e4944e51 *R/capture.output.R dc36b33860d9fa47b76725c5c1793f31 *R/dQuote.R 8ed21dc3461c82e76ecaa51ea5bbba0b *R/deparse1.R e1fb60c17ea8a6677c3a80637f88c830 *R/dir.exists.R da64e21c278b5017993dcc2321552c8f *R/dotsElt.R 481b7311ab8961c4fef48b8ec6cd5eb0 *R/dotsLength.R 0fb613fa78490cd6f5ff7a88f1656763 *R/dotsNames.R 8d6708837ab0c9222d582576160dcdeb *R/endsWith.R daf73a06568906502efabcfa63cc3f45 *R/file.info.R f03ad94562dfb233f213366ceb192900 *R/file.mode.R 9733ea86cf7e4e2ad39c226b68ab73ff *R/file.mtime.R fd795349608133c5b9b4850c8bce7115 *R/file.size.R a9a4fe845be20018fb88d4d57237eb01 *R/get0.R b8bd9db45b49fe62e5101de2d80ac4ef *R/hasName.R ed0bb4085860ad7431bf312c94248258 *R/import.R 71f82c7d4d76ea1bcf50c4882f2922a0 *R/isFALSE.R b6a23c8fa8e7b95266a59a8a9e9df3aa *R/isNamespaceLoaded.R 72a820a36c75b726315cdfb20fd025ac *R/isTRUE.R 7784e570a0e427a85eb0b54cc04d494c *R/lengths.R b79ae58d493ff912dde3efd15df65bd7 *R/libPaths.R 9fa4f27a194d3742a1089db9a0dbfb71 *R/list2DF.R 19b34ed7a3b0090726db82088ebe2146 *R/null_coalesce.R d2e6f4defdc9042a1dcf187b57634ed1 *R/paste.R 927ac9909aaa1f226a4381c43770d1c5 *R/paste0.R 785727dc006a54f96c6b69acce6fceca *R/removeSource.R 1d59834fa8a4c2572b8a047376837618 *R/startsWith.R cc35f9f3031992d3d50471b07e53ca67 *R/stopifnot.R 822ae9549b2c556551e07866f370e75e *R/str2expression.R 793e0383a107d5dad46e394a28be1711 *R/str2lang.R a4f40e3e2747b16bfe0cc6e80766e0f7 *R/strrep.R 7eb5cd5c0ffcd8069fbca150f1fb366b *R/suppressWarnings.R 2281b9271b328f1ce44735f433c57a1b *R/trimws.R f0a491f2249c61d129127d5277b428db *R/valid.factor.R b08798c5a61f613c60c595fbe01978a1 *R/vignetteInfo.R fdad95605776f3d0a6dca00edacc3d50 *R/warningCondition.R f1ec157e58d129cd1099700ce24ca795 *R/zzz.R e05f3225bbc5ad6ab60fee0106da0385 *README.md e668b5dd4f52ce96df2cf5e26d976eac *man/R_user_dir.Rd 9502c207e8163009cd99aaacefd6f544 *man/URLencode.Rd 5c3ef8d8d05cd9f2b6d63210b5924faa *man/anyNA.Rd c6842d68782fe08de4368c642699ab25 *man/as.Rconcordance.Rd 7dae936cb33920428097b0225f4c4a07 *man/as.Rconcordance.default.Rd 3eb788d445602ef60f3e89bcbdf11dda *man/as.character.Rconcordance.Rd ea27c68a89fb392dbd5a2cdf6e301c84 *man/asplit.Rd 7448db6e5bd6c61ce7ca26aec4b29444 *man/backports-package.Rd 7a57f80bd4560bd34f86c3ecc6c06a07 *man/capture.output.Rd 37f9ce75db00bf0f39ba0472ee971695 *man/dQuote.Rd ee249685c9b3c6f4abbeab6f8810dfb6 *man/deparse1.Rd a96f841e5bb26d875daafdec0ca3a12e *man/dir.exists.Rd 4b811bda283420d6bda01b250112119b *man/dotsElt.Rd 54f762138570780eaacbd437e19c6ff4 *man/dotsLength.Rd 701cd339f2e8e5162f59e2296e01f59c *man/dotsNames.Rd fff4aab715b29f9a293e46eedbba73fc *man/endsWith.Rd 4ad72c0183de86f7435b66fdd617dbf2 *man/file.info.Rd f0364a969e7687778d4b2e2a651612a0 *man/file.size.Rd 28cd0eaf06e1bb3ef808783fc9f217b2 *man/get0.Rd f6d4b60d090845baa1d66917e6c649ae *man/hasName.Rd 82c1d09b33edcb8c578c9452f0ff621a *man/import.Rd 0ef694f3021e07f821b76875888c6702 *man/isFALSE.Rd f415d30f4a3d44535d0284772c3da60a *man/isNamespaceLoaded.Rd f066fb3e9ac733f714e68ee655df099d *man/isTRUE.Rd 3193f8a1b410c99da87cdfd2306e4741 *man/lengths.Rd a34085a669409b5a901ff7f041535bf6 *man/libPaths.Rd 43983f6cda7904738876df3fa5ae6f19 *man/list2DF.Rd a014a38ee99c32a6309086d2469cd81e *man/matchConcordance.Rd 7f8ac6aa816ce9cc96fedba9dd4d9534 *man/null_coalesce_operator.Rd 74c56e6a9d2e37c3bb6234ccf1f01b44 *man/paste.Rd 43841fff08714a10e37c67c48a5efd67 *man/paste0.Rd 01b2db9248014f9563930519cb8f94d8 *man/print.Rconcordance.Rd 70614d95852850d6397d3b8ba989bdee *man/removeSource.Rd 0a5e953c05afce33ff2f200ce43cb536 *man/startsWith.Rd 74454413551ad2fe17d32e3e5e31d5df *man/stopifnot.Rd 2647092889aef0ff7d93077dd3ee1f5c *man/str2expression.Rd 8ec5b025dd692bb1d3bda04626086d2a *man/str2lang.Rd 71dccde721e5e07b058ea9988d2aa758 *man/strrep.Rd 7b35b49308e1e7291350c0541be8d0d7 *man/suppressWarnings.Rd 44c533774b88159cbd550b9d842d65a2 *man/trimws.Rd f2ab99b5fe125ca043a77b89ff74bcf5 *man/valid.factor.Rd 636be43bf723e385435321ffed55f176 *man/vignetteInfo.Rd a9c2a5a46917fa75d978f04b1eeb3b16 *man/warningCondition.Rd d59274bb19ef27e3774e9d1bed9fb93e *src/dotsElt.c dea82a2ee366ce1253864931672df2cd *src/dotsLength.c 747eb6ee7c6060d846601e3ae4b8582b *src/dotsNames.c 1c4098d3f662615ed26268422e84ae5e *src/init.c 070b0a063bc14f81216f936fb895aac2 *tests/helper/helper.R a0cf596bf842ac7cab73d837ee3474b7 *tests/test_R_user_dir.R 85d258572afd961bc43629b7e6c4c741 *tests/test_Rconcordance.R 472c0a48b52a2cf6f60d468ffe85afc8 *tests/test_URLencode.R 1b97afed1a49ba2f7e7588661dd78481 *tests/test_anyNA.R 4099f5f989efacd5650a8ecee103a337 *tests/test_asplit.R cdfdb1d1a0d354ef4cccf55d5c761268 *tests/test_capture.output.R 73d6561fbcd5c310a6ac298d76366462 *tests/test_dQuote.R 23a1a69bf7aac5601ac82f63d8e046d7 *tests/test_deparse1.R d012f4fc8d451334726a1609bb6d0584 *tests/test_dir.exists.R 4d340dde3ed93644990d650c9b7e2ff1 *tests/test_dotlibPaths.R ff243305cbfd7c6c20dcf75a8b2f9b2c *tests/test_dotsElt.R 18ccf5227a80053f5b65dea32dff8562 *tests/test_dotsLength.R 51f17c715548a08b7de1dc5b7447e219 *tests/test_dotsNames.R d20ca8e00de706dfca77fc4e7e079a30 *tests/test_file.info.R 8863972af374c21d56ea2625f357d1c1 *tests/test_file.mode.R 80309a60390999f8c875299d5343311a *tests/test_file.mtime.R 608d8ef6d47fde8c311efeb92600e7c5 *tests/test_file.size.R 8bbb0281ed2c45c26a8b1fe8829a8426 *tests/test_get0.R 224c4b67349277afb9ab178127d03470 *tests/test_hasName.R d8037fd4dfd75db762b138fe8e74cab3 *tests/test_isFALSE.R 9fef1041765a8612c73e04539bbaa479 *tests/test_isNamespaceLoaded.R 6bfeb283a68c31874f2368bc1845fc0c *tests/test_isTRUE.R 01ea7785d2d97d7364427f69ee028e43 *tests/test_lengths.R 5b26f503c05074ce2524adeda18d3338 *tests/test_list2DF.R 97eee0ed8a3ae06dfc1b8f115c1c606a *tests/test_null_coalesce.R 00a8645d02dadda4791d59a7583c8452 *tests/test_paste.R dcc12c9d11b7e6eb0b595695426e1f41 *tests/test_removeSource.R f5a7d4c6f5a89cd18a06029135ad1e57 *tests/test_startsWith.R 8d2777be3c8d6bc1121cf3f35506ee13 *tests/test_stopifnot.R 13f0e147e70337373583fb5361c512b7 *tests/test_str2expression.R 5c66a69aca9736c82b1b77b6fe66184a *tests/test_str2lang.R f7bb3f7fe9fcfd990f6090c5fce29870 *tests/test_strrep.R f62529aa2b845343c8442f2a0e005698 *tests/test_suppressWarnings.R 7ff35bbbb455c565d8ebcac87a015d22 *tests/test_trimws.R 89fd82c6ff2f443f75a69210c9acd26b *tests/test_valid.factor.R 48b5e09cb37ff576bca7627146b1fb73 *tests/test_warningCondition.R