R/setupProject.R
setupPackages.RdCombine the modules' reqdPkgs with the user-supplied packages and
install all of them into paths[["packagePath"]] via Require::Install().
setupPackages(
packages,
modulePackages = list(),
require = list(),
paths,
libPaths,
setLinuxBinaryRepo = TRUE,
standAlone,
envir = parent.frame(),
callingEnv = sys.frame(-2),
verbose = getOption("Require.verbose"),
dots,
defaultDots,
...
)Optional. A vector of packages that must exist in the libPaths.
This will be passed to Require::Install, i.e., these will be installed, but
not attached to the search path. See also the require argument. To force skip
of package installation (without assessing modules), set packages = NULL
A named list, where names are the module names, and the elements
of the list are packages in a form that Require::Require accepts.
Optional. A character vector of packages to install and attach
(with Require::Require). These will be installed and attached at the start
of setupProject so that a user can use these during setupProject.
See setup
a list with named elements, specifically, modulePath, projectPath,
packagePath and all others that are in SpaDES.core::setPaths()
(i.e., inputPath, outputPath, scratchPath, cachePath, rasterTmpDir).
Each of these has a sensible default, which will be overridden but any user
supplied values.
See setup.
Deprecated. Use paths = list(packagePath = ...).
Logical. Should the binary RStudio Package Manager be used on Linux (ignored if Windows)
A logical. Passed to Require::standAlone. This keeps all
packages installed in a project-level library, if TRUE. Default is TRUE.
The environment where setupProject is called from. Defaults to
parent.frame() which should be fine in most cases and user shouldn't need
to set this
The environment from which the function was called. Defaults to sys.frame(-2)
which represents the case where the inner setup* functions are called inside
setupProject, which was called by a user.
Numeric or logical indicating how verbose the function should be.
At verbose >= 2, the combined reqdPkgs are printed grouped by module. At
verbose >= 3, additionally the dput() of the exact package vector passed to
Require::Require is printed, which can be copy-pasted to reproduce the install
call. If not supplied, defaults to getOption("Require.verbose").
Any other named objects passed as a list a user might want for other elements.
A named list of any arbitrary R objects.
These can be supplied to give default values to objects that
are otherwise passed in with the ..., i.e., not specifically named for these
setup* functions. If named objects are supplied as top-level arguments, then
the defaultDots will be overridden. This can be particularly useful if the
arguments passed to ... do not always exist, but rely on external e.g., batch
processing to optionally fill them. See examples.
further named arguments that acts like objects, but a different
way to specify them. These can be anything. The general use case
is to create the objects that are would be passed to
SpaDES.core::simInit, or SpaDES.core::simInitAndSpades,
(e.g. studyAreaName or objects) or additional objects to be passed to the simulation
(in older versions of SpaDES.core, these were passed as a named list
to the objects argument). Order matters. These are sequentially evaluated,
and also any arguments that are specified before the named arguments
e.g., name, paths, will be evaluated prior to any of the named arguments,
i.e., "at the start" of the setupProject.
If placed after the first named argument, then they will be evaluated at the
end of the setupProject, so can access all the packages, objects, etc.
setupPackages is run for its side effects, i.e., installing packages to
paths[["packagePath"]].
setupPackages will read the modules' metadata reqdPkgs element. It will combine
these with any packages passed manually by the user to packages, and pass all
these packages to Require::Install(...).
setupProject() for the high-level wrapper, setup_family for an overview.