This will first look in local filesystem (in .libPaths()
) and will use a
local package to find its dependencies. If the package does not exist
locally, including whether it is the correct version, then it will look in
(currently) CRAN
and its archives (if the current CRAN
version is not the
desired version to check). It will also look on GitHub
if the package
description is of the form of a GitHub package with format
account/repo@branch
or account/repo@commit
. For this, it will attempt to
get package dependencies from the GitHub DESCRIPTION
file. This is
intended to replace tools::package_dependencies
or pkgDep
in the
miniCRAN package, but with modifications to allow multiple sources to
be searched in the same function call.
pkgDep2
is a convenience wrapper of pkgDep
that "goes one level in",
i.e., the first order dependencies, and runs the pkgDep
on those.
This is a wrapper around tools::dependsOnPkgs
,
but with the added option of sorted
, which
will sort them such that the packages at the top will have
the least number of dependencies that are in pkgs
.
This is essentially a topological sort, but it is done
heuristically. This can be used to e.g., detach
or
unloadNamespace
packages in order so that they each
of their dependencies are detached or unloaded first.
pkgDep(
packages,
libPath = .libPaths(),
which = c("Depends", "Imports", "LinkingTo"),
recursive = FALSE,
depends,
imports,
suggests,
linkingTo,
repos = getOption("repos"),
keepVersionNumber = TRUE,
includeBase = FALSE,
sort = TRUE,
purge = getOption("Require.purge", FALSE),
verbose = getOption("Require.verbose"),
includeSelf = TRUE,
type = getOption("pkgType")
)pkgDep2(
packages,
recursive = TRUE,
which = c("Depends", "Imports", "LinkingTo"),
depends,
imports,
suggests,
linkingTo,
repos = getOption("repos"),
sorted = TRUE,
purge = getOption("Require.purge", FALSE),
includeSelf = TRUE,
verbose = getOption("Require.verbose")
)
pkgDepTopoSort(
pkgs,
deps,
reverse = FALSE,
topoSort = TRUE,
libPath = .libPaths(),
useAllInSearch = FALSE,
returnFull = TRUE,
recursive = TRUE,
purge = getOption("Require.purge", FALSE),
which = c("Depends", "Imports", "LinkingTo"),
type = getOption("pkgType"),
verbose = getOption("Require.verbose")
)
A possibly ordered, named (with packages as names) list where list elements are either full reverse depends.
Character vector of packages to install via
install.packages
, then load (i.e., with library
). If it is one package,
it can be unquoted (as in require
). In the case of a GitHub package, it
will be assumed that the name of the repository is the name of the package.
If this is not the case, then pass a named character vector here, where the
names are the package names that could be different than the GitHub
repository name.
A path to search for installed packages. Defaults to
.libPaths()
a character vector listing the types of dependencies, a subset
of c("Depends", "Imports", "LinkingTo", "Suggests", "Enhances")
.
Character string "all"
is shorthand for that vector, character string
"most"
for the same vector without "Enhances"
.
Logical. Should dependencies of dependencies be searched,
recursively. NOTE: Dependencies of suggests will not be recursive. Default
TRUE
.
Logical. Include packages listed in "Depends". Default TRUE
.
Logical. Include packages listed in "Imports". Default TRUE
.
Logical. Include packages listed in "Suggests". Default
FALSE
.
Logical. Include packages listed in "LinkingTo". Default
TRUE
.
The remote repository (e.g., a CRAN mirror), passed to either
install.packages
, install_github
or installVersions
.
Logical. If TRUE
, then the package dependencies
returned will include version number. Default is FALSE
Logical. Should R base packages be included, specifically,
those in tail(.libPath(), 1)
Logical. If TRUE
, the default, then the packages will be sorted
alphabetically. If FALSE
, the packages will not have a discernible order
as they will be a concatenation of the possibly recursive package
dependencies.
Logical. Should all caches be purged? Default is
getOption("Require.purge", FALSE)
. There is a lot of internal caching of
results throughout the Require
package. These help with speed and reduce
calls to internet sources. However, sometimes these caches must be purged.
The cached values are renewed when found to be too old, with the age limit.
This maximum age can be set in seconds with the environment variable
R_AVAILABLE_PACKAGES_CACHE_CONTROL_MAX_AGE
, or if unset, defaults to 3600
(one hour -- see utils::available.packages
).
Internally, there are calls to available.packages
.
Numeric or logical indicating how verbose should the function
be. If -1 or -2, then as little verbosity as possible. If 0 or FALSE,
then minimal outputs; if 1
or TRUE, more outputs; 2
even more. NOTE: in
Require
function, when verbose >= 2
, the return object will have an
attribute: attr(.., "Require")
which has lots of information about the
processes of the installs.
Logical. If TRUE
, the default, then the dependencies
will include the package itself in the returned list elements, otherwise,
only the "dependencies"
Logical. If TRUE
, the default, the packages will be sorted in
the returned list from most number of dependencies to least.
A vector of package names to evaluate their reverse depends (i.e., the packages that use each of these packages)
An optional named list of (reverse) dependencies.
If not supplied, then tools::dependsOnPkgs(..., recursive = TRUE)
will be used
Logical. If TRUE
, then this will use tools::pkgDependsOn
to determine which packages depend on the pkgs
Logical. If TRUE
, the default, then
the returned list of packages will be in order with the
least number of dependencies listed in pkgs
at
the top of the list.
Logical. If TRUE
, then all non-core
R packages in search()
will be appended to pkgs
to allow those to also be identified
Logical. Primarily useful when reverse = TRUE
.
If TRUE
, then then all installed packages will be searched.
If FALSE
, the default, only packages that are currently in
the search()
path and passed in pkgs
will be included
in the possible reverse dependencies.
if (FALSE) {
if (Require:::.runLongExamples()) {
opts <- Require:::.setupExample()
pkgDep("tidyverse", recursive = TRUE)
# GitHub, local, and CRAN packages
pkgDep(c("PredictiveEcology/reproducible", "Require", "plyr"))
Require:::.cleanup(opts)
}
}
if (FALSE) {
if (Require:::.runLongExamples()) {
opts <- Require:::.setupExample()
pkgDep2("reproducible")
# much bigger one
pkgDep2("tidyverse")
Require:::.cleanup(opts)
}
}
if (FALSE) {
if (Require:::.runLongExamples()) {
opts <- Require:::.setupExample()
pkgDepTopoSort(c("Require", "data.table"), reverse = TRUE)
Require:::.cleanup(opts)
}
}
Run the code above in your browser using DataLab