getCachePath() asserts that the user has write permissions to
the cache path. If not, an error is produced. Previously, this
check was only done when the cache folder did not exist and had to
be created. Now it also checked pre-existing folders. For
performance reasons, this check is only done once per R session.memoizeCall() would not always find previously cached results,
because R's just-in-time (JIT) compiler could cause the internal
state of the memomized function to change. Thanks to Tomas
Kalibera for reporting on this and proposing the fix (already back
in 2017).The location of the root cache folder as introduced in R.cache
0.14.0 has been updated to match that of tools::R_user_dir(),
which was introduced in R 4.0.0. On Linux, this was already the
case in R.cache 0.14.0, whereas on macOS and MS Windows, the
folder locations have changed slightly. If an old cache folder
location is detected, then the user will be queried what action to
take, i.e. abort, ignore the old folder, remove the old folder, or
move the old folder to the new location. In non-interactive mode,
the default action is always to ignore.
The package will no longer ask for permission to create the cache
folder as long as the cache folder is compatible with
tools::R_user_dir().
~/.Rcache. On Unix, the 'XDG
Base Directory Specification' is followed, which means that the
R.cache folder will typically be ~/.cache/R/R.cache/. On
macOS, it will be ~/Library/Caches/R/R.cache/. On modern
versions of Microsoft Windows, environment variables such as
LOCALAPPDATA will be used, which typically resolves to
%USERPROFILE%/AppData/Local, e.g. C:/Users/alice/AppData/Local.
If R.cache fails to find a proper OS-specific cache folder, it
will fall back to using ~/.Rcache as previously done.
Importantly, if ~/.Rcache already exists, then that will be used
by default. This is done in order to not lose previously cached
files. Users with an existing folder who wish to move to the new
standard need to move or remove the ~/.Rcache folder manually.Add generateCache() to generate cache pathnames from a key
without creating the cache file. This function was previously not
exported.
Option R.cache.rootPath now defaults to environment variable
R_CACHE_ROOTPATH if it is set.
evalWithMemoization() gained argument drop to specify which
attributes to drop from the expression object. The default is to
now drop any source-reference attributes.
evalWithMemoization(expr) failed to memoize in knitr
documents because although the same expr was specified they
differed internally due to source-reference attributes.
evalWithMemoization() used partial dollar name matching in one
place.
R.cache::rootPath,
R.cache::touchOnLoad, and R.cache::compress are now defunct.
Likewise, environment variable R_CACHE_PATH and argument
onError="print" for loadCache() are now defunct.R CMD check, unless one is explicitly set via an option or an
environment variable.Now package gives a more informative error message in the rare cases it fails to create the cache root directory or fails to save a cache file.
Updated loadCache() to recognize new file-format version 3 coming
to R.
Added options R.cache.enabled, which defaults to TRUE, for
controlling whether loadCache() and saveCache() should
read/write from cache or not. This provides an easy mechanism for
temporarily disabling R.cache.
Harmonized R.cache options to all have names prefixed with
R.cache..
clearCache() now prompts the user via readline(), which is
always visible, i.e. it can neither be captured nor sinked.
Using onError = "print" for loadCache() is deprecated and
replaced by new onError = "message".
Deprecated R.cache options R.cache::rootPath,
R.cache::touchOnLoad, and R.cache::compress. Use
R.cache.rootPath, R.cache.touchOnLoad, and R.cache.compress
instead.
Now all prompt and verbose messages are send to the standard error (instead of the standard output).
SPEEDUP: Now memoizedCall() generates cache pathname only once.
verbose from memoizedCall().memoizeCall() and
addMemoization().addMemoization() will no longer memoize an already memoized
function.::.generateCache() with key = NULL would give
a hard-to-understand error message. Now it's more informative.Added arguments path and rootPath to getCachePath().
Added argument pathname to saveCache().
~/.Rcache/, which in turn could cause that
path to be create without asking the user. For instance,
R.cache::loadCache(list()) would do. Thanks to Kurt Hornik at
Vienna University of Economics and Business for reporting on this.Authors field matches Authors@R.R.cache Package object is also available when the
package is only loaded (but not attached).Now only importing a minimal set of functions needed from the R.oo and the R.utils packages.
Bumped package dependencies.
clearCache() is exported (re-exported from R.oo).R.cache:::.assertDigest() called from within another package
would give an error that packageVersion() of utils was not
found.getChecksum() passes ... to digest(), e.g. argument
algo.loadCache() - replaced an rm() call with NULL
assignment.CRAN POLICY: Now all Rd \usage{} lines are at most 90 characters
long.
Bumped package dependencies.
startupMessage() of R.oo.clearCache(..., recursive = TRUE).clearCache() would give error "object 'dirs' not found".Package now only imports R.methodsS3 and R.oo, no long depends (attaches) them. It still needs to load R.utils.
Now package exports a smaller set of the methods.
ROBUSTNESS: Now package declares S3 methods in the namespace.
Added internal .assertDigest(), which originates from
aroma.core.
... to NextMethod(), cf. R-devel
thread 'Do not pass '...' to NextMethod() - it'll do it for you;
missing documentation, a bug or just me?' on Oct 16, 2012..Rcache/ directory to _Rcache/ to avoid
R CMD check NOTEs..Internal() for loading
saved data. This could be done in a backward-compatible way using
readRDS()..Internal() function..Rcache directory.~/.Rcache/. However,
if it does not exists, then it is created when the package is
loaded, but only after approval by the user (via a textual
prompt). If not approved, or it is not possible to prompt the user
(e.g. in a non-interactive session), then a session-specific
temporary directory is used.getCachePath() and setCacheRootPath() add a README.txt file
to the root path, iff missing. It explains why the directory
structure exists, what created it, and that it is safe to delete.readCacheHeader() iff
running R v2.12.2 or before. Thanks to Uwe Ligges (R core) for
reporting on this.Added support for saving and loading compressed cache files.
Now package uses packageStartupMessage() instead of cat().
findCache() asserts that any identified cache
file is really a file.dirs (in methods using it) specifies the
subdirectory of the cache root directory.prompt for clearCache() defaults to TRUE iff
interactive() is TRUE, otherwise FALSE.clearCache().Now generateCache() utilizes a generic function getChecksum()
to obtain the checksum. This makes it possible to customize how
checksums are calculated for different classes of objects.
Added a default getChecksum() which utilizes digest::digest().
Added getChecksum() for the Object, which first clears the
cache of the object and the calls the default ditto.
Added trial version of evalWithMemoization().
clearCache() would also report on subdirectories.memoizedCall() and addMemoization().loadFromConn() does not exists.onError to loadCache(), to specify the action
when an error occurs. The default used to be to print the error
message (onError = "print"), but now it generates a warning
("warning"). The other alternatives are do silently ignore it, or
to throw the error ("error"). Except for onError = "error",
loadCache() always returns NULL if an error occurs.readCacheHeader() reports the "pathname" in error/warnings
messages, if argument file refers to a file and the "description"
if it refers to a connection.ROBUSTNESS: Added sanity check to readCacheHeader() testing that
the read header identifier is non-empty. This results in a clearer
error message that before.
Renamed the HISTORY file to NEWS.
Added option to updated the "last-modified" timestamp of cache
files whenever they are loaded via loadCache(). This will help
identified what cache files have not been used for a long time. To
turn this on, use options("R.cache::touchOnLoad" = TRUE).
Now error messages specifies the pathname, if available.
throw() for invalid identifiers was trying to put the
connection object in the output and not the identifier.R CMD check on R v2.6.0 devel. Minor mods.getCacheRootPath() to the help index page.R CMD check on R v2.5.0.getCacheRootPath() and setCacheRootPath() to specify
where the root of the file path is located.Now saveCache() and loadCache() takes optional argument dirs
for caching data to subdirectories of the root cache directory.
Added setCacheRootPath() to set the root cache directory.
pathname to loadCache() in order to load
"unknown" cache files for which the key is unknown.base::save(), which otherwise includes all of the surrounding
environment if 'sources' is not evaluated/missing. For more
details see code and my email to r-devel on 2006-05-25. Thanks to
Brian Ripley for explaining what was going on.Added readCacheHeader().
Added detection of file format version.
Using a special binary file format now. It allows you to check if cache is up-to-date to a source file. If not, the rest of the cache binary file is not loaded.
Added loadCache() and saveCache() methods.
Created.