CRAN Package Check Results for Package tabplot

Last updated on 2020-02-19 10:49:12 CET.

Check Details

Version: 1.3-3
Check: examples
Result: ERROR
    Running examples in 'tabplot-Ex.R' failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: num2fac
    > ### Title: Transform a numerical vector to a factor
    > ### Aliases: num2fac
    >
    > ### ** Examples
    >
    > require(ggplot2)
    Loading required package: ggplot2
    > data(diamonds)
    >
    > diamonds$price2 <- num2fac(diamonds$price)
    Loading required namespace: classInt
    >
    > tableplot(diamonds)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x1ba8530>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct") :
     the condition has length > 1
    Calls: tableplot
    Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.3-3
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
     ...
    --- re-building 'tabplot-timings.Rmd' using knitr
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(p, plot = FALSE)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(p, plot = FALSE)
    where 2: system.time(tab <- tableplot(p, plot = FALSE))
    where 3: eval(expr, envir, enclos)
    where 4: eval(expr, envir, enclos)
    where 5: withVisible(eval(expr, envir, enclos))
    where 6: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 7: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 10: evaluate::evaluate(...)
    where 11: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 12: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 13: block_exec(params)
    where 14: call_block(x)
    where 15: process_group.block(group)
    where 16: process_group(group)
    where 17: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 18: process_file(text, output)
    where 19: knit(input, text = text, envir = envir, quiet = quiet)
    where 20: knit2html(..., force_v1 = TRUE)
    where 21: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 22: engine$weave(file, quiet = quiet, encoding = enc)
    where 23: doTryCatch(return(expr), name, parentenv, handler)
    where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 25: tryCatchList(expr, classes, parentenv, handlers)
    where 26: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 27: tools:::.buildOneVignette("tabplot-timings.Rmd", "/home/hornik/tmp/R.check/r-devel-clang/Work/PKGS/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-timings", "", "/tmp/RtmpS1g4Mw/file1db9495857a7.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x72ec9d8>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 55-58 (tabplot-timings.Rmd)
    Timing stopped at: 1.451 0.198 1.965
    Error: processing vignette 'tabplot-timings.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building 'tabplot-timings.Rmd'
    
    --- re-building 'tabplot-vignette.Rmd' using knitr
    Loading required package: ggplot2
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    where 2: eval(expr, envir, enclos)
    where 3: eval(expr, envir, enclos)
    where 4: withVisible(eval(expr, envir, enclos))
    where 5: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 6: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 7: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 8: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 9: evaluate::evaluate(...)
    where 10: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 11: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 12: block_exec(params)
    where 13: call_block(x)
    where 14: process_group.block(group)
    where 15: process_group(group)
    where 16: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 17: process_file(text, output)
    where 18: knit(input, text = text, envir = envir, quiet = quiet)
    where 19: knit2html(..., force_v1 = TRUE)
    where 20: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 21: engine$weave(file, quiet = quiet, encoding = enc)
    where 22: doTryCatch(return(expr), name, parentenv, handler)
    where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 24: tryCatchList(expr, classes, parentenv, handlers)
    where 25: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 26: tools:::.buildOneVignette("tabplot-vignette.Rmd", "/home/hornik/tmp/R.check/r-devel-clang/Work/PKGS/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-vignette", "", "/tmp/RtmpS1g4Mw/file1db96830dce7.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x4f87a20>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 37-38 (tabplot-vignette.Rmd)
    Error: processing vignette 'tabplot-vignette.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building 'tabplot-vignette.Rmd'
    
    SUMMARY: processing the following files failed:
     'tabplot-timings.Rmd' 'tabplot-vignette.Rmd'
    
    Error: Vignette re-building failed.
    Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.3-3
Check: examples
Result: ERROR
    Running examples in ‘tabplot-Ex.R’ failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: num2fac
    > ### Title: Transform a numerical vector to a factor
    > ### Aliases: num2fac
    >
    > ### ** Examples
    >
    > require(ggplot2)
    Loading required package: ggplot2
    > data(diamonds)
    >
    > diamonds$price2 <- num2fac(diamonds$price)
    Loading required namespace: classInt
    >
    > tableplot(diamonds)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x55b73063bb60>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct") :
     the condition has length > 1
    Calls: tableplot
    Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 1.3-3
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
     ...
    --- re-building ‘tabplot-timings.Rmd’ using knitr
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(p, plot = FALSE)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(p, plot = FALSE)
    where 2: system.time(tab <- tableplot(p, plot = FALSE))
    where 3: eval(expr, envir, enclos)
    where 4: eval(expr, envir, enclos)
    where 5: withVisible(eval(expr, envir, enclos))
    where 6: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 7: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 10: evaluate::evaluate(...)
    where 11: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 12: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 13: block_exec(params)
    where 14: call_block(x)
    where 15: process_group.block(group)
    where 16: process_group(group)
    where 17: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 18: process_file(text, output)
    where 19: knit(input, text = text, envir = envir, quiet = quiet)
    where 20: knit2html(..., force_v1 = TRUE)
    where 21: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 22: engine$weave(file, quiet = quiet, encoding = enc)
    where 23: doTryCatch(return(expr), name, parentenv, handler)
    where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 25: tryCatchList(expr, classes, parentenv, handlers)
    where 26: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 27: tools:::.buildOneVignette("tabplot-timings.Rmd", "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-timings", "", "/home/hornik/tmp/scratch/RtmpfM7EFZ/file571d72bdc3f5.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x564976a7c838>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 55-58 (tabplot-timings.Rmd)
    Timing stopped at: 1.246 0.128 2.063
    Error: processing vignette 'tabplot-timings.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-timings.Rmd’
    
    --- re-building ‘tabplot-vignette.Rmd’ using knitr
    Loading required package: ggplot2
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    where 2: eval(expr, envir, enclos)
    where 3: eval(expr, envir, enclos)
    where 4: withVisible(eval(expr, envir, enclos))
    where 5: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 6: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 7: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 8: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 9: evaluate::evaluate(...)
    where 10: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 11: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 12: block_exec(params)
    where 13: call_block(x)
    where 14: process_group.block(group)
    where 15: process_group(group)
    where 16: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 17: process_file(text, output)
    where 18: knit(input, text = text, envir = envir, quiet = quiet)
    where 19: knit2html(..., force_v1 = TRUE)
    where 20: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 21: engine$weave(file, quiet = quiet, encoding = enc)
    where 22: doTryCatch(return(expr), name, parentenv, handler)
    where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 24: tryCatchList(expr, classes, parentenv, handlers)
    where 25: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 26: tools:::.buildOneVignette("tabplot-vignette.Rmd", "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-vignette", "", "/home/hornik/tmp/scratch/RtmpfM7EFZ/file571d4ecd8e30.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x5633d52ec498>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 37-38 (tabplot-vignette.Rmd)
    Error: processing vignette 'tabplot-vignette.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-vignette.Rmd’
    
    SUMMARY: processing the following files failed:
     ‘tabplot-timings.Rmd’ ‘tabplot-vignette.Rmd’
    
    Error: Vignette re-building failed.
    Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 1.3-3
Check: package dependencies
Result: WARN
    Requires orphaned package: ‘bit’
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.3-3
Check: examples
Result: ERROR
    Running examples in ‘tabplot-Ex.R’ failed
    The error most likely occurred in:
    
    > ### Name: num2fac
    > ### Title: Transform a numerical vector to a factor
    > ### Aliases: num2fac
    >
    > ### ** Examples
    >
    > require(ggplot2)
    Loading required package: ggplot2
    > data(diamonds)
    >
    > diamonds$price2 <- num2fac(diamonds$price)
    Loading required namespace: classInt
    >
    > tableplot(diamonds)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x39cab88>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct") :
     the condition has length > 1
    Calls: tableplot
    Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.3-3
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
    --- re-building ‘tabplot-timings.Rmd’ using knitr
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(p, plot = FALSE)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(p, plot = FALSE)
    where 2: system.time(tab <- tableplot(p, plot = FALSE))
    where 3: eval(expr, envir, enclos)
    where 4: eval(expr, envir, enclos)
    where 5: withVisible(eval(expr, envir, enclos))
    where 6: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 7: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 10: evaluate::evaluate(...)
    where 11: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 12: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 13: block_exec(params)
    where 14: call_block(x)
    where 15: process_group.block(group)
    where 16: process_group(group)
    where 17: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 18: process_file(text, output)
    where 19: knit(input, text = text, envir = envir, quiet = quiet)
    where 20: knit2html(..., force_v1 = TRUE)
    where 21: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 22: engine$weave(file, quiet = quiet, encoding = enc)
    where 23: doTryCatch(return(expr), name, parentenv, handler)
    where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 25: tryCatchList(expr, classes, parentenv, handlers)
    where 26: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 27: tools:::.buildOneVignette("tabplot-timings.Rmd", "/data/gannet/ripley/R/packages/tests-clang/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-timings", "", "/tmp/Rtmpl0x0DG/working_dir/RtmpBEONIY/file84e25301fbfd.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x6dd2238>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 55-58 (tabplot-timings.Rmd)
    Timing stopped at: 1.825 0.22 2.082
    Error: processing vignette 'tabplot-timings.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-timings.Rmd’
    
    --- re-building ‘tabplot-vignette.Rmd’ using knitr
    Loading required package: ggplot2
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    where 2: eval(expr, envir, enclos)
    where 3: eval(expr, envir, enclos)
    where 4: withVisible(eval(expr, envir, enclos))
    where 5: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 6: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 7: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 8: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 9: evaluate::evaluate(...)
    where 10: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 11: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 12: block_exec(params)
    where 13: call_block(x)
    where 14: process_group.block(group)
    where 15: process_group(group)
    where 16: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 17: process_file(text, output)
    where 18: knit(input, text = text, envir = envir, quiet = quiet)
    where 19: knit2html(..., force_v1 = TRUE)
    where 20: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 21: engine$weave(file, quiet = quiet, encoding = enc)
    where 22: doTryCatch(return(expr), name, parentenv, handler)
    where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 24: tryCatchList(expr, classes, parentenv, handlers)
    where 25: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 26: tools:::.buildOneVignette("tabplot-vignette.Rmd", "/data/gannet/ripley/R/packages/tests-clang/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-vignette", "", "/tmp/Rtmpl0x0DG/working_dir/RtmpBEONIY/file84e24315b567.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x4054b28>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 37-38 (tabplot-vignette.Rmd)
    Error: processing vignette 'tabplot-vignette.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-vignette.Rmd’
    
    SUMMARY: processing the following files failed:
     ‘tabplot-timings.Rmd’ ‘tabplot-vignette.Rmd’
    
    Error: Vignette re-building failed.
    Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.3-3
Check: examples
Result: ERROR
    Running examples in ‘tabplot-Ex.R’ failed
    The error most likely occurred in:
    
    > ### Name: num2fac
    > ### Title: Transform a numerical vector to a factor
    > ### Aliases: num2fac
    >
    > ### ** Examples
    >
    > require(ggplot2)
    Loading required package: ggplot2
    > data(diamonds)
    >
    > diamonds$price2 <- num2fac(diamonds$price)
    Loading required namespace: classInt
    >
    > tableplot(diamonds)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x37ee7a0>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct") :
     the condition has length > 1
    Calls: tableplot
    Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 1.3-3
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
    --- re-building ‘tabplot-timings.Rmd’ using knitr
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(p, plot = FALSE)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(p, plot = FALSE)
    where 2: system.time(tab <- tableplot(p, plot = FALSE))
    where 3: eval(expr, envir, enclos)
    where 4: eval(expr, envir, enclos)
    where 5: withVisible(eval(expr, envir, enclos))
    where 6: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 7: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 10: evaluate::evaluate(...)
    where 11: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 12: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 13: block_exec(params)
    where 14: call_block(x)
    where 15: process_group.block(group)
    where 16: process_group(group)
    where 17: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 18: process_file(text, output)
    where 19: knit(input, text = text, envir = envir, quiet = quiet)
    where 20: knit2html(..., force_v1 = TRUE)
    where 21: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 22: engine$weave(file, quiet = quiet, encoding = enc)
    where 23: doTryCatch(return(expr), name, parentenv, handler)
    where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 25: tryCatchList(expr, classes, parentenv, handlers)
    where 26: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 27: tools:::.buildOneVignette("tabplot-timings.Rmd", "/data/gannet/ripley/R/packages/tests-devel/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-timings", "", "/tmp/RtmposSmrz/working_dir/Rtmptr3UFz/file1b2c43b07312.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x68616e0>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 55-58 (tabplot-timings.Rmd)
    Timing stopped at: 1.884 0.338 2.364
    Error: processing vignette 'tabplot-timings.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-timings.Rmd’
    
    --- re-building ‘tabplot-vignette.Rmd’ using knitr
    Loading required package: ggplot2
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    tabplot
     --- call from context ---
    tableplot(diamonds)
     --- call from argument ---
    if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error") stop("<colorNA> is not correct")
     --- R stacktrace ---
    where 1: tableplot(diamonds)
    where 2: eval(expr, envir, enclos)
    where 3: eval(expr, envir, enclos)
    where 4: withVisible(eval(expr, envir, enclos))
    where 5: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler,
     error = eHandler, message = mHandler)
    where 6: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir,
     enclos)), warning = wHandler, error = eHandler, message = mHandler))
    where 7: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr,
     envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    where 8: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,
     debug = debug, last = i == length(out), use_try = stop_on_error !=
     2L, keep_warning = keep_warning, keep_message = keep_message,
     output_handler = output_handler, include_timing = include_timing)
    where 9: evaluate::evaluate(...)
    where 10: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning),
     keep_message = !isFALSE(options$message), stop_on_error = if (options$error &&
     options$include) 0L else 2L, output_handler = knit_handlers(options$render,
     options))
    where 11: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE,
     keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message),
     stop_on_error = if (options$error && options$include) 0L else 2L,
     output_handler = knit_handlers(options$render, options)))
    where 12: block_exec(params)
    where 13: call_block(x)
    where 14: process_group.block(group)
    where 15: process_group(group)
    where 16: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
     error = function(e) {
     setwd(wd)
     cat(res, sep = "\n", file = output %n% "")
     message("Quitting from lines ", paste(current_lines(i),
     collapse = "-"), " (", knit_concord$get("infile"),
     ") ")
     })
    where 17: process_file(text, output)
    where 18: knit(input, text = text, envir = envir, quiet = quiet)
    where 19: knit2html(..., force_v1 = TRUE)
    where 20: (if (grepl("\\.[Rr]md$", file)) knit2html_v1 else if (grepl("\\.[Rr]rst$",
     file)) knit2pandoc else knit)(file, encoding = encoding,
     quiet = quiet, envir = globalenv(), ...)
    where 21: engine$weave(file, quiet = quiet, encoding = enc)
    where 22: doTryCatch(return(expr), name, parentenv, handler)
    where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    where 24: tryCatchList(expr, classes, parentenv, handlers)
    where 25: tryCatch({
     engine$weave(file, quiet = quiet, encoding = enc)
     setwd(startdir)
     output <- find_vignette_product(name, by = "weave", engine = engine)
     if (!have.makefile && vignette_is_tex(output)) {
     texi2pdf(file = output, clean = FALSE, quiet = quiet)
     output <- find_vignette_product(name, by = "texi2pdf",
     engine = engine)
     }
    }, error = function(e) {
     OK <<- FALSE
     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",
     file, conditionMessage(e)))
    })
    where 26: tools:::.buildOneVignette("tabplot-vignette.Rmd", "/data/gannet/ripley/R/packages/tests-devel/tabplot.Rcheck/vign_test/tabplot",
     TRUE, FALSE, "tabplot-vignette", "", "/tmp/RtmposSmrz/working_dir/Rtmptr3UFz/file1b2c7662f332.rds")
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (dat, select, subset = NULL, sortCol = 1, decreasing = TRUE,
     nBins = 100, from = 0, to = 100, nCols = ncol(dat), sample = FALSE,
     sampleBinSize = 1000, scales = "auto", numMode = "mb-sdb-ml",
     max_levels = 50, pals = list("Set1", "Set2", "Set3", "Set4"),
     change_palette_type_at = 20, rev_legend = FALSE, colorNA = "#FF1414",
     colorNA_num = "gray75", numPals = "OrBu", limitsX = NULL,
     bias_brokenX = 0.8, IQR_bias = 5, select_string = NULL, subset_string = NULL,
     colNames = NULL, filter = NULL, plot = TRUE, ...)
    {
     p <- dat
     is_prepared <- inherits(dat, "prepared")
     if (!is_prepared) {
     datName <- deparse(substitute(dat))
     p <- tablePrepare(dat, name = datName)
     }
     else datName <- attr(p, "name")
     dat <- p$data
     if (!missing(colNames)) {
     warning("The argument colNames will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse select or select_string instead")
     select_string <- colNames
     }
     if (!missing(filter)) {
     warning("The argument filter will not be supported \n\t\t\t\tanymore in the future versions of tabplot. \n\t\t\t\tUse subset or subset_string instead")
     subset_string <- filter
     }
     if (!missing(subset)) {
     subset_string <- deparse(substitute(subset))
     }
     else if (!missing(subset_string)) {
     subset <- parse(text = subset_string)
     }
     if (!missing(select)) {
     select_string <- as.character(substitute(select))
     if (any(sapply(select_string, function(x) substr(x, 1,
     1) %in% as.character(0:9)))) {
     nl <- as.list(seq_along(dat))
     names(nl) <- names(dat)
     select_string <- eval(substitute(select), nl, parent.frame())
     select_string <- names(dat)[select_string]
     }
     else {
     select_call <- deparse(substitute(select))
     if ((substr(select_call[1], 1, 2)) == "c(")
     select_string <- select_string[-1]
     }
     }
     if (!is.null(select_string)) {
     allColNames <- strsplit(select_string, "[ ]?-[ ]?")
     colNames1 <- sapply(allColNames, function(x) x[1])
     colNames2 <- sapply(allColNames, function(x) x[2])
     colNames <- unique(c(colNames1, na.omit(colNames2)))
     if (!all(colNames %in% names(dat)))
     stop("select(_string) contains wrong column names")
     }
     else {
     colNames <- names(dat)
     colNames1 <- colNames
     colNames2 <- rep(NA, length(colNames))
     }
     colNames_string <- mapply(function(x, y) ifelse(is.na(y),
     x, paste(x, y, sep = "-")), colNames1, colNames2, SIMPLIFY = TRUE)
     sortCol <- tableplot_checkCols(substitute(sortCol), sortCol,
     colNames)
     sortColName <- colNames[sortCol]
     if (!(sortColName %in% colNames_string))
     stop("sortCol should be plotted")
     if (!missing(subset_string)) {
     if (subset_string %in% names(dat)) {
     lvls <- levels(dat[[subset_string]])
     if ((class(dat[[subset_string]])[1] == "logical") ||
     (class(dat)[1] == "ffdf" && vmode(dat[[subset_string]]) %in%
     c("boolean", "logical"))) {
     isLogical <- TRUE
     lvls <- c("TRUE", "FALSE")
     }
     else {
     isLogical <- FALSE
     }
     if (is.null(lvls))
     stop("subset variable is not categorical")
     subsets_string <- paste(subset_string, " == ", ifelse(isLogical,
     "", "\""), lvls, ifelse(isLogical, "", "\""),
     sep = "")
     tabs <- lapply(subsets_string, FUN = function(subs_string) {
     tableplot(p, select_string = colNames_string,
     sortCol = sortCol, decreasing = decreasing,
     scales = scales, max_levels = max_levels, pals = pals,
     nBins = nBins, from = from, to = to, subset_string = subs_string,
     change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA,
     colorNA_num = colorNA_num, numPals = numPals,
     limitsX = limitsX, bias_brokenX = bias_brokenX,
     IQR_bias = IQR_bias, plot = plot, ...)
     })
     return(invisible(tabs))
     }
     p <- subset_data(p, cols = colNames, subset_string = subset_string,
     sortCol = sortCol)
     dat <- p$data
     }
     isNumber <- sapply(physical(dat)[colNames], function(col) !is.factor.ff(col) &&
     !vmode(col) == "logical")
     if (nrow(dat) == 0)
     stop("<dat> doesn't have any rows")
     if (nrow(dat) == 1)
     stop("<dat> has only one row")
     decreasing <- tableplot_checkDecreasing(decreasing, sortCol)
     nCols <- tableplot_checkNcols(nCols, colNames, sortCol)
     scales <- tableplot_checkScales(scales, colNames, isNumber)
     pals <- tableplot_checkPals(pals, colNames, !isNumber)
     if (any(!isNumber))
     change_palette_type_at <- tableplot_checkChangePalType(change_palette_type_at,
     max(sapply(pals[!isNumber], function(pal) length(pal$palette))))
     if (class(try(col2rgb(colorNA), silent = TRUE)) == "try-error")
     stop("<colorNA> is not correct")
     if (class(try(col2rgb(colorNA_num), silent = TRUE)) == "try-error")
     stop("<colorNA_num> is not correct")
     rev_legend <- tableplot_checkRevLeg(rev_legend, colNames)
     numPals <- tableplot_checkNumPals(numPals, colNames, isNumber)
     limitsX <- if (missing(limitsX))
     list()
     else tableplot_checkLimitsX(limitsX, colNames, isNumber)
     tableplot_checkFromTo(from, to)
     N <- as.integer(length(p$ordered[[1]]) * (to - from)/100)
     nBins <- tableplot_checkBins(nBins, max(N, 2))
     n <- ifelse(sample, min(nBins * sampleBinSize, N), N)
     numMode <- strsplit(numMode, "-", fixed = TRUE)[[1]]
     bd <- bin_data(p, sortCol = sortCol, cols = colNames, from = from/100,
     to = to/100, nbins = nBins, decreasing = decreasing,
     sample, sampleBinSize = sampleBinSize)
     bd <- bin_hcc_data(bd, max_levels)
     tab <- columnTable(bd, datName, colNames = colNames, subset_string = subset_string,
     sortCol = sortCol, decreasing = decreasing, scales = scales,
     pals = pals, change_palette_type_at = change_palette_type_at,
     rev_legend = rev_legend, colorNA = colorNA, colorNA_num = colorNA_num,
     numPals = numPals, nBins = nBins, from = from, to = to,
     N = N, n = n)
     if (!is_prepared)
     lapply(p, ff::close.ffdf)
     tab <- tableplot_processCols(tab, colNames1, colNames2, IQR_bias,
     bias_brokenX, limitsX, nBins, sortColName, numMode)
     if (nCols < length(colNames)) {
     tabs <- splitTab(tab, nCols)
     if (plot)
     sapply(tabs, plot, ...)
     invisible(tabs)
     }
     else {
     if (plot)
     plot(tab, ...)
     invisible(tab)
     }
    }
    <bytecode: 0x4dd5160>
    <environment: namespace:tabplot>
     --- function search by body ---
    Function tableplot in namespace tabplot has this body.
     ----------- END OF FAILURE REPORT --------------
    Quitting from lines 37-38 (tabplot-vignette.Rmd)
    Error: processing vignette 'tabplot-vignette.Rmd' failed with diagnostics:
    the condition has length > 1
    --- failed re-building ‘tabplot-vignette.Rmd’
    
    SUMMARY: processing the following files failed:
     ‘tabplot-timings.Rmd’ ‘tabplot-vignette.Rmd’
    
    Error: Vignette re-building failed.
    Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc