Merge pull request #11 from miraisolutions/feature/address-macos-cran…

…-checks

Address macos CRAN checks

.travis.yml

@@ -1,14 +1,44 @@
 # R for travis: see documentation at https://docs.travis-ci.com/user/languages/r
 
-language: R
+language: r
 cache: packages
+warnings_are_errors: true
+
+r:
+- devel
+- release
+- oldrel
+
+# TeXLive issues for osx images
+# https://travis-ci.community/t/latex-error-file-inconsolata-sty-not-found-only-on-osx-when-building-r-package/3261/4
+
+os:
+- linux
+# - osx
 
-matrix:
+# Vanilla macOS machine: remove preinstalled homebrew installation
+disable_homebrew: true
+
+jobs:
+#  exclude:
+#  # macOS binary packages not available for r-devel
+#  - r: devel
+#    os: osx
   include:
-  - r: devel
   - r: release
-    after_success:
-    - Rscript -e 'covr::codecov()'
+    os: osx
+    r_check_args: --no-manual
   - r: oldrel
+    os: osx
+    r_check_args: --no-manual
+
+# Code coverage
+after_success:
+  - >-
+    if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$TRAVIS_R_VERSION_STRING" = "release" ]; then
+      echo Code coverage...
+      Rscript -e 'covr::codecov(type = "all")'
+    else
+      echo Skip code coverage
+    fi
 
-warnings_are_errors: true

DESCRIPTION

@@ -41,7 +41,7 @@ VignetteBuilder:
 Encoding: UTF-8
 LazyData: true
 NeedsCompilation: yes
-RoxygenNote: 7.0.2
+RoxygenNote: 7.1.0
 Collate: 
     'LdFlags.R'
     'RcppExports.R'

NAMESPACE

@@ -7,6 +7,7 @@ export(TRNGjump)
 export(TRNGkind)
 export(TRNGseed)
 export(TRNGsplit)
+export(check_rTRNG_linking)
 export(defaultKind)
 export(lagfib2plus_19937_64)
 export(lagfib2xor_19937_64)

NEWS.md

@@ -4,6 +4,8 @@
 
 - Underlying TRNG C++ library upgraded to version 4.22 (#6). This mainly includes: Fixing numerical convergence problems in the inverse of the incomplete Beta function; Removing support for C++ language standards older than C++11.
 - Documentation and examples updated to include enforcing the C++11 standard required by the updated TRNG C++ library.
+- New function `check_rTRNG_linking()` allows checking whether C++ code using the TRNG library can be built and linked against rTRNG (#10).
+- Package vignettes now use `check_rTRNG_linking()` to build C++ code using TRNG only on systems supporting it. This addresses the vignette re-building issues in the CRAN package checks on macOS (and Solaris), and is broadly documented in the package, including README and vignettes (#10).
 
 # rTRNG 4.20-1
 

R/LdFlags.R

@@ -56,3 +56,34 @@ asBuildPath <- function(path) {
   }
   return(path)
 }
+
+sourceCpp_minimal_code <- '
+// [[Rcpp::depends(rTRNG)]]
+// [[Rcpp::plugins(cpp11)]]
+#include <Rcpp.h>
+#include <trng/yarn2.hpp>
+// [[Rcpp::export]]
+void exampleCpp() {
+  trng::yarn2 rng;
+}
+'
+
+#' Check rTRNG linking.
+#'
+#' Check whether C++ code using the TRNG library can be built and linked against
+#' \pkg{rTRNG} on the current system.
+#'
+#' @inheritParams base::try
+#'
+#' @return A scalar logical with the result of the check. If \code{FALSE}, using
+#'   the TRNG library from C++ code sourced via \code{\link[Rcpp]{sourceCpp}} or
+#'   part of an \R package is not expected to work.
+#'
+#' @export
+check_rTRNG_linking <- function(silent = FALSE) {
+  check <- try(
+    silent = silent,
+    Rcpp::sourceCpp(code = sourceCpp_minimal_code)
+  )
+  !inherits(check, "try-error")
+}

R/rTRNG-package.R

@@ -45,6 +45,13 @@
 #'       \code{importFrom(rTRNG, TRNG.Version)} in the NAMESPACE file, and
 #'       setting relevant linker flags (via \code{\link[rTRNG]{LdFlags}}) and
 #'       C++11 compilation (\code{CXX_STD = CXX11}) in Makevars[.win].
+#'     \item
+#'       Note that C++ code using the TRNG library (sourced via
+#'       \code{Rcpp::sourceCpp} or part of an \R package) might fail on certain
+#'       systems due to issues with building and linking against \pkg{rTRNG}.
+#'       This is typically the case for macOS, and can generally be checked
+#'       using
+#'       \code{\link[rTRNG]{check_rTRNG_linking}}.
 #'     }
 #' }
 #' See the package vignettes (\code{browseVignettes("rTRNG")}) for an overview

README.Rmd

@@ -156,7 +156,6 @@ x_serial <- rnorm_trng(1e5L)
 identical(x_serial, x_parallel)
 ```
 
-
 ### Use TRNG from standalone C++
 
 The TRNG C++ library is made available by **rTRNG** to standalone C++ code
@@ -199,3 +198,13 @@ Creating an R package with C++ code using the TRNG library and headers through
     - Makevars: `PKG_LIBS += $(shell ${R_HOME}/bin/Rscript -e "rTRNG::LdFlags()")`
     - Makevars.win: `PKG_LIBS += $(shell "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" -e "rTRNG::LdFlags()")`
 
+### Note about C++ code on macOS
+
+C++ code using the TRNG library (sourced via `Rcpp::sourceCpp` or part of an R
+package) might fail on certain systems due to issues with building and linking
+against **rTRNG**. This is typically the case for  **macOS**, and can generally
+be checked by running
+
+```{r check-linking, eval=FALSE}
+rTRNG::check_rTRNG_linking()
+```

README.md

@@ -190,3 +190,14 @@ through **rTRNG** is achieved by
         "rTRNG::LdFlags()")`
       - Makevars.win: `PKG_LIBS += $(shell
         "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" -e "rTRNG::LdFlags()")`
+
+### Note about C++ code on macOS
+
+C++ code using the TRNG library (sourced via `Rcpp::sourceCpp` or part
+of an R package) might fail on certain systems due to issues with
+building and linking against **rTRNG**. This is typically the case for
+**macOS**, and can generally be checked by running
+
+``` r
+rTRNG::check_rTRNG_linking()
+```

tests/testthat/test-TRNG.Engine.R

@@ -262,11 +262,11 @@ test_that("$split errors for out-of-range subsequence indices", {
     p <- 5L
     if (!grepl("(lagfib|mt)", engineClass)) {
       expect_error(
-        e$split(p, 0L), "invalid", # 1-base indexing
+        e$split(p, 0L), class = "std::invalid_argument", # 1-base indexing
         info = .name(engineClass)
       )
       expect_error(
-        e$split(p, p + 1L), "invalid",
+        e$split(p, p + 1L), class = "std::invalid_argument",
         info = .name(engineClass)
       )
       expect_error(

tests/testthat/test-TRNG.Random.R

@@ -131,8 +131,8 @@ test_that("TRNGsplit errors for out-of-range subsequence indices", {
   TRNGkind(KIND)
   TRNGseed(SEED)
   p <- 5L
-  expect_error(TRNGsplit(p, 0L), "invalid") # 1-base indexing
-  expect_error(TRNGsplit(p, p + 1L), "invalid")
+  expect_error(TRNGsplit(p, 0L), class = "std::invalid_argument") # 1-base indexing
+  expect_error(TRNGsplit(p, p + 1L), class = "std::invalid_argument")
   expect_error(TRNGsplit(p, -1L), "negative")
   expect_error(TRNGsplit(-1L, 1L), "negative")
 })

vignettes/mcMat.Rmd

@@ -13,16 +13,19 @@ vignette: >
 ```{r setup, include=FALSE}
 knitr::opts_chunk$set(collapse = TRUE)
 options(digits = 5) # for kable
+linking_ok <- rTRNG::check_rTRNG_linking()
 ```
 
 
-```{r include=FALSE, cache=FALSE}
+```{r code, include=FALSE, cache=FALSE}
 source("utils/read_chunk_wrap.R", echo = FALSE, print.eval = FALSE)
 read_chunk_wrap("code/mcMat.R")
-Rcpp::sourceCpp("code/mcMat.cpp", verbose = FALSE, embeddedR = FALSE)
 read_chunk_wrap("code/mcMat.cpp")
-Rcpp::sourceCpp("code/mcMatParallel.cpp", verbose = FALSE, embeddedR = FALSE)
 read_chunk_wrap("code/mcMatParallel.cpp")
+if (linking_ok) {
+  Rcpp::sourceCpp("code/mcMat.cpp", verbose = FALSE, embeddedR = FALSE)
+  Rcpp::sourceCpp("code/mcMatParallel.cpp", verbose = FALSE, embeddedR = FALSE)
+}
 ```
 
 Consider the Monte Carlo simulation of a matrix of i.i.d. normal random
@@ -71,9 +74,9 @@ enforces the C++11 standard required by TRNG >= 4.22.
 ```
 As seen above for the R case, consistency of the simulation obtained via
 `mcSubMatRcpp` with the full sequential simulation is guaranteed.
-```{r subMatExampleRcpp}
+```{r subMatExampleRcpp, eval=linking_ok}
 ```
-```{r, echo=FALSE}
+```{r, echo=FALSE, eval=linking_ok}
 knitr::kable(cbind.data.frame(M = M, S = S), row.names = TRUE)
 ```
 
@@ -88,12 +91,12 @@ Monte Carlo simulations in parallel, for any subset `subCols` of the variables.
 ```
 The parallel nature of the `yarn2` generator ensures the parallel simulation is
 playing fair, i.e. is consistent with the sequential simulation.
-```{r fullMatExampleRcppParallel}
+```{r fullMatExampleRcppParallel, eval=linking_ok}
 ```
 Similarly, we can achieve a consistent parallel simulation of a subset of the
 variables only.
-```{r subMatExampleRcppParallel}
+```{r subMatExampleRcppParallel, eval=linking_ok}
 ```
-```{r, echo=FALSE}
+```{r, echo=FALSE, eval=linking_ok}
 knitr::kable(cbind.data.frame(M = M, Sp = Sp), row.names = TRUE)
 ```

vignettes/rTRNG.Rmd

@@ -12,6 +12,7 @@ vignette: >
 
 ```{r setup, include=FALSE}
 knitr::opts_chunk$set(echo = TRUE, collapse = TRUE)
+linking_ok <- rTRNG::check_rTRNG_linking()
 ```
 
 
@@ -105,7 +106,7 @@ easily be compiled, specifying the `Rcpp::depends` attribute that allows
 `Rcpp::plugins(cpp11)` is needed to enforce the C++11 standard required by TRNG
 >= 4.22.
 
-```{Rcpp sourceCpp}
+```{Rcpp sourceCpp, eval=linking_ok}
 // [[Rcpp::depends(rTRNG)]]
 // TRNG >= 4.22 requires C++11
 // [[Rcpp::plugins(cpp11)]]
@@ -132,7 +133,7 @@ NumericVector exampleCpp() {
 exampleCpp()
 */
 ```
-```{r sourceCpp-R, echo=FALSE}
+```{r sourceCpp-R, echo=FALSE, eval=linking_ok}
 exampleCpp()
 ```
 
@@ -148,3 +149,15 @@ Creating an R package with C++ code using the TRNG library and headers through
 - setting the relevant linker flags in Makevars[.win] via `rTRNG::LdFlags()`
     - Makevars: `PKG_LIBS += $(shell ${R_HOME}/bin/Rscript -e "rTRNG::LdFlags()")`
     - Makevars.win: `PKG_LIBS += $(shell "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" -e "rTRNG::LdFlags()")`
+
+
+### Note about C++ code on macOS
+
+C++ code using the TRNG library (sourced via `Rcpp::sourceCpp` or part of an R
+package) might fail on certain systems due to issues with building and linking
+against **rTRNG**. This is typically the case for **macOS**, and can generally
+be checked by running
+
+```{r check-linking, eval=FALSE}
+rTRNG::check_rTRNG_linking()
+```