Require (version 0.0.6)

pkgDep: Determine package dependencies

Description

This will first look in local filesystem (in .libPaths()), then CRAN. If the package is in the form of a GitHub package with format account/repo@branch, it will attempt to get package dependencies from the GitHub DESCRIPTION file. Currently, it will not find Remotes. 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.

Usage

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)
)
pkgDep2(
  packages,
  recursive = TRUE,
  which = c("Depends", "Imports", "LinkingTo"),
  depends,
  imports,
  suggests,
  linkingTo,
  repos = getOption("repos"),
  sorted = TRUE
)
pkgDepTopoSort(
  pkgs,
  deps,
  reverse = FALSE,
  topoSort = TRUE,
  useAllInSearch = FALSE,
  returnFull = TRUE,
  recursive = TRUE
)

Arguments

packages

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.

libPath

A path to search for installed packages. Defaults to .libPaths()

which

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".

recursive

Logical. Should dependencies of dependencies be searched, recursively. NOTE: Dependencies of suggests will not be recursive. Default TRUE.

depends

Logical. Include packages listed in "Depends". Default TRUE.

imports

Logical. Include packages listed in "Imports". Default TRUE.

suggests

Logical. Include packages listed in "Suggests". Default FALSE.

linkingTo

Logical. Include packages listed in "LinkingTo". Default TRUE.

repos

The remote repository (e.g., a CRAN mirror), passed to either install.packages, install_github or installVersions.

keepVersionNumber

Logical. If TRUE, then the package dependencies returned will include version number. Default is FALSE

includeBase

Logical. Should R base packages be included, specifically, those in tail(.libPath(), 1)

sort

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.

purge

Logical. Internally, there are calls to available.packages

sorted

Logical. If TRUE, the default, the packages will be sorted in the returned list from most number of dependencies to least.

pkgs

A vector of package names to evaluate their reverse depends (i.e., the packages that use each of these packages)

deps

An optional named list of (reverse) dependencies. If not supplied, then tools::dependsOnPkgs(..., recursive = TRUE) will be used

reverse

Logical. If TRUE, then this will use tools::pkgDependsOn to determine which packages depend on the pkgs

topoSort

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.

useAllInSearch

Logical. If TRUE, then all non-core R packages in search() will be appended to pkgs to allow those to also be identified

returnFull

Logical. If TRUE, then the full reverse dependencies will be returned; if FALSE, the default, only the reverse dependencies that are found within the pkgs (and search() if useAllInSearch = TRUE) will be returned.

Value

A possibly ordered, named (with packages as names) list where list elements are either full reverse depends.

Examples

# NOT RUN {
pkgDep("Require")
# }
# NOT RUN {
  pkgDep("Require", keepVersionNumber = FALSE) # just names
  pkgDep("PredictiveEcology/reproducible") # GitHub
  pkgDep("PredictiveEcology/reproducible", recursive = TRUE) # GitHub
  pkgDep(c("PredictiveEcology/reproducible", "Require")) # GitHub package and local packages
  pkgDep(c("PredictiveEcology/reproducible", "Require", "plyr")) # GitHub, local, and CRAN packages
# }
# NOT RUN {
pkgDep2("Require")
# }
# NOT RUN {
# much bigger one
pkgDep2("reproducible")
# }
# NOT RUN {
pkgDepTopoSort(c("Require", "data.table"), reverse = TRUE)
# }