Nothing
# This file contains helper functions copied from ggplot2.
# from gglpot2 utilities-grid.r
ggname <- function(prefix, grob) {
grob$name <- grobName(grob, prefix)
grob
}
# from gglpot2 ggproto.r
ggproto_formals <- function(x) formals(environment(x)$f)
# from gglpot2 layer.r
obj_desc <- function(x) {
if (isS4(x)) {
paste0("an S4 object with class ", class(x)[[1]])
} else if (is.object(x)) {
if (is.data.frame(x)) {
"a data frame"
} else if (is.factor(x)) {
"a factor"
} else {
paste0("an S3 object with class ", paste(class(x), collapse = "/"))
}
} else {
switch(typeof(x),
"NULL" = "a NULL",
character = "a character vector",
integer = "an integer vector",
logical = "a logical vector",
double = "a numeric vector",
list = "a list",
closure = "a function",
paste0("a base object of type", typeof(x))
)
}
}
# from gglpot2 scale-type.r
find_global <- function(name, env, mode = "any") {
if (exists(name, envir = env, mode = mode)) {
return(get(name, envir = env, mode = mode))
}
nsenv <- asNamespace("ggiraph")
if (exists(name, envir = nsenv, mode = mode)) {
return(get(name, envir = nsenv, mode = mode))
}
NULL
}
# from gglpot2 utilities.r
camelize <- function(x, first = FALSE) {
x <- gsub("_(.)", "\\U\\1", x, perl = TRUE)
if (first) x <- firstUpper(x)
x
}
# from gglpot2 utilities.r
firstUpper <- function(s) {
paste(toupper(substring(s, 1, 1)), substring(s, 2), sep = "")
}
# from ggplot2 utilities.r
is.waive <- function(x) inherits(x, "waiver")
# from ggplot2 utilities.r
empty <- function(df) {
is.null(df) || nrow(df) == 0 || ncol(df) == 0 || is.waive(df)
}
# from ggplot2 utilities.r
"%||%" <- function(a, b) {
if (!is.null(a)) a else b
}
# from ggplot2 utilities.r
message_wrap <- function(...) {
msg <- paste(..., collapse = "", sep = "")
wrapped <- strwrap(msg, width = getOption("width") - 2)
message(paste0(wrapped, collapse = "\n"))
}
# from ggplot2 grob-null.r
is.zero <- function(x)
is.null(x) || inherits(x, "zeroGrob")
# from gglpot2 utilities.r
compact <- function(x) {
null <- vapply(x, is.null, logical(1))
x[!null]
}
# from ggplot2 geom.r
check_aesthetics <- function(x, n) {
ns <- vapply(x, length, numeric(1))
good <- ns == 1L | ns == n
if (all(good)) {
return()
}
abort(paste0(
"Aesthetics must be either length 1 or the same as the data (", n, "):\n",
paste(names(which(!good)), collapse = ", ")
))
}
# from ggplot2 compat-plyr.R
rename <- function(x, replace) {
current_names <- names(x)
old_names <- names(replace)
missing_names <- setdiff(old_names, current_names)
if (length(missing_names) > 0) {
replace <- replace[!old_names %in% missing_names]
old_names <- names(replace)
}
names(x)[match(old_names, current_names)] <- as.vector(replace)
x
}
#' @importFrom vctrs vec_unique
unique0 <- function(x, ...) {
if (is.null(x)) x else vctrs::vec_unique(x, ...)
}
#' @importFrom vctrs data_frame
data_frame0 <- function(...) data_frame(..., .name_repair = "minimal")
#' Apply function to unique subsets of a data.frame
#'
#' This function is akin to `plyr::ddply`. It takes a single data.frame,
#' splits it by the unique combinations of the columns given in `by`, apply a
#' function to each split, and then reassembles the results into a sigle
#' data.frame again.
#'
#' @param df A data.frame
#' @param by A character vector of column names to split by
#' @param fun A function to apply to each split
#' @param ... Further arguments to `fun`
#' @param drop Should unused factor levels in the columns given in `by` be
#' dropped.
#'
#' @return A data.frame if the result of `fun` does not include the columns
#' given in `by` these will be prepended to the result.
#'
#' @keywords internal
#' @noRd
#' @importFrom vctrs vec_slice
#' @importFrom stats setNames
dapply <- function(df, by, fun, ..., drop = TRUE) {
grouping_cols <- .subset(df, by)
fallback_order <- unique0(c(by, names(df)))
apply_fun <- function(x) {
res <- fun(x, ...)
if (is.null(res)) return(res)
if (length(res) == 0) return(data_frame0())
vars <- lapply(setNames(by, by), function(col) .subset2(x, col)[1])
if (is.matrix(res)) res <- split_matrix(res)
if (is.null(names(res))) names(res) <- paste0("V", seq_along(res))
if (all(by %in% names(res))) return(data_frame0(!!!unclass(res)))
res <- modify_list(unclass(vars), unclass(res))
res <- res[intersect(c(fallback_order, names(res)), names(res))]
data_frame0(!!!res)
}
# Shortcut when only one group
has_single_group <- all(vapply(
grouping_cols,
function(x) identical(as.character(levels(x) %||% attr(x, "n")), "1"),
logical(1)
))
if (has_single_group) {
return(apply_fun(df))
}
ids <- id(grouping_cols, drop = drop)
group_rows <- split_with_index(seq_len(nrow(df)), ids)
result <- lapply(seq_along(group_rows), function(i) {
cur_data <- vec_slice(df, group_rows[[i]])
apply_fun(cur_data)
})
vec_rbind0(!!!result)
}
split_with_index <- function(x, f, n = max(f)) {
if (n == 1) return(list(x))
f <- as.integer(f)
attributes(f) <- list(levels = as.character(seq_len(n)), class = "factor")
unname(split(x, f))
}
# Adapted from plyr:::id_vars
# Create a unique id for elements in a single vector
id_var <- function(x, drop = FALSE) {
if (length(x) == 0) {
id <- integer()
n <- 0L
} else if (!is.null(attr(x, "n")) && !drop) {
return(x)
} else if (is.factor(x) && !drop) {
x <- addNA(x, ifany = TRUE)
id <- as.integer(x)
n <- nlevels(x)
} else {
levels <- sort(unique0(x), na.last = TRUE)
id <- match(x, levels)
n <- max(id)
}
attr(id, "n") <- n
id
}
#' Create an unique integer id for each unique row in a data.frame
#'
#' Properties:
#' - `order(id)` is equivalent to `do.call(order, df)`
#' - rows containing the same data have the same value
#' - if `drop = FALSE` then room for all possibilities
#'
#' @param .variables list of variables
#' @param drop Should unused factor levels be dropped?
#'
#' @return An integer vector with attribute `n` giving the total number of
#' possible unique rows
#'
#' @keywords internal
#' @noRd
#' @importFrom rlang inject
id <- function(.variables, drop = FALSE) {
nrows <- NULL
if (is.data.frame(.variables)) {
nrows <- nrow(.variables)
.variables <- unclass(.variables)
}
lengths <- lengths(.variables)
.variables <- .variables[lengths != 0]
if (length(.variables) == 0) {
n <- nrows %||% 0L
id <- seq_len(n)
attr(id, "n") <- n
return(id)
}
if (length(.variables) == 1) {
return(id_var(.variables[[1]], drop = drop))
}
ids <- rev(lapply(.variables, id_var, drop = drop))
p <- length(ids)
ndistinct <- vapply(ids, attr, "n", FUN.VALUE = numeric(1), USE.NAMES = FALSE)
n <- prod(ndistinct)
if (n > 2^31) {
char_id <- inject(paste(!!!ids, sep = "\r"))
res <- match(char_id, unique0(char_id))
}
else {
combs <- c(1, cumprod(ndistinct[-p]))
mat <- inject(cbind(!!!ids))
res <- c((mat - 1L) %*% combs + 1L)
}
if (drop) {
id_var(res, drop = TRUE)
}
else {
res <- as.integer(res)
attr(res, "n") <- n
res
}
}
#' @importFrom rlang current_env
vec_rbind0 <- function(..., .error_call = current_env(), .call = caller_env()) {
with_ordered_restart(
vec_rbind(..., .error_call = .error_call),
.call
)
}
split_matrix <- function(x, col_names = colnames(x)) {
force(col_names)
x <- lapply(seq_len(ncol(x)), function(i) x[, i])
if (!is.null(col_names)) names(x) <- col_names
x
}
#' @importFrom rlang zap format_error_call is_null
#' @importFrom vctrs vec_ptype2 vec_cast
# Restart handler for using vec_rbind with mix of types
# Ordered is coerced to factor
# If a character vector is present the other is converted to character
with_ordered_restart <- function(expr, .call) {
withCallingHandlers(
expr,
vctrs_error_incompatible_type = function(cnd) {
x <- cnd[["x"]]
y <- cnd[["y"]]
class_x <- class(x)[1]
class_y <- class(y)[1]
restart <- FALSE
if (is.ordered(x) || is.ordered(y)) {
restart <- TRUE
if (is.ordered(x)) {
x <- factor(as.character(x), levels = levels(x))
}
if (is.ordered(y)) {
y <- factor(as.character(y), levels = levels(y))
}
} else if (is.character(x) || is.character(y)) {
restart <- TRUE
if (is.character(x)) {
y <- as.character(y)
} else {
x <- as.character(x)
}
} else if (is.factor(x) || is.factor(y)) {
restart <- TRUE
lev <- c()
if (is.factor(x)) {
lev <- c(lev, levels(x))
}
if (is.factor(y)) {
lev <- c(lev, levels(y))
}
x <- factor(as.character(x), levels = unique(lev))
y <- factor(as.character(y), levels = unique(lev))
}
# Don't recurse and let ptype2 error keep its course
if (!restart) {
return(zap())
}
msg <- paste0("Combining variables of class <", class_x, "> and <", class_y, ">")
desc <- paste0(
"Please ensure your variables are compatible before plotting (location: ",
format_error_call(.call),
")"
)
cli::cli_warn(
I(paste(msg, "was deprecated in ggplot2 3.4.0.", desc))
)
x_arg <- cnd[["x_arg"]]
y_arg <- cnd[["y_arg"]]
call <- cnd[["call"]]
# Recurse with factor methods and restart with the result
if (inherits(cnd, "vctrs_error_ptype2")) {
out <- vec_ptype2(x, y, x_arg = x_arg, y_arg = y_arg, call = call)
restart <- "vctrs_restart_ptype2"
} else if (inherits(cnd, "vctrs_error_cast")) {
out <- vec_cast(x, y, x_arg = x_arg, to_arg = y_arg, call = call)
restart <- "vctrs_restart_cast"
} else {
return(zap())
}
# Old-R compat for `tryInvokeRestart()`
try_restart <- function(restart, ...) {
if (!is_null(findRestart(restart))) {
invokeRestart(restart, ...)
}
}
try_restart(restart, out)
}
)
}
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.