version 1.0.5

DESCRIPTION

@@ -1,7 +1,7 @@
 Type: Package
 Package: dplyr
 Title: A Grammar of Data Manipulation
-Version: 1.0.4
+Version: 1.0.5
 Authors@R: 
     c(person(given = "Hadley",
              family = "Wickham",
@@ -27,23 +27,24 @@ License: MIT + file LICENSE
 URL: https://dplyr.tidyverse.org, https://github.com/tidyverse/dplyr
 BugReports: https://github.com/tidyverse/dplyr/issues
 Depends: R (>= 3.3.0)
-Imports: ellipsis, generics, glue (>= 1.3.2), lifecycle (>= 0.2.0),
-        magrittr (>= 1.5), methods, R6, rlang (>= 0.4.9), tibble (>=
+Imports: ellipsis, generics, glue (>= 1.3.2), lifecycle (>= 1.0.0),
+        magrittr (>= 1.5), methods, R6, rlang (>= 0.4.10), tibble (>=
         2.1.3), tidyselect (>= 1.1.0), utils, vctrs (>= 0.3.5)
 Suggests: bench, broom, callr, covr, DBI, dbplyr (>= 1.4.3), knitr,
         Lahman, lobstr, microbenchmark, nycflights13, purrr, rmarkdown,
-        RMySQL, RPostgreSQL, RSQLite, testthat (>= 2.1.0), withr
+        RMySQL, RPostgreSQL, RSQLite, testthat (>= 3.0.2), tidyr, withr
 VignetteBuilder: knitr
 Encoding: UTF-8
 LazyData: true
 RoxygenNote: 7.1.1
+Config/testthat/edition: 3
 NeedsCompilation: yes
-Packaged: 2021-02-01 10:59:21 UTC; romainfrancois
+Packaged: 2021-02-19 10:54:12 UTC; romainfrancois
 Author: Hadley Wickham [aut, cre] (<https://orcid.org/0000-0003-4757-117X>),
   Romain François [aut] (<https://orcid.org/0000-0002-2444-4226>),
   Lionel Henry [aut],
   Kirill Müller [aut] (<https://orcid.org/0000-0002-1416-3412>),
   RStudio [cph, fnd]
 Maintainer: Hadley Wickham <hadley@rstudio.com>
 Repository: CRAN
-Date/Publication: 2021-02-02 17:10:03 UTC
+Date/Publication: 2021-03-05 11:00:02 UTC

NEWS.md

@@ -1,3 +1,18 @@
+# dplyr 1.0.5
+
+* Fixed edge case of `slice_sample()` when `weight_by=` is used and there 
+  0 rows (#5729). 
+
+* `across()` can again use columns in functions defined inline (#5734). 
+
+* Using testthat 3rd edition. 
+
+* Fixed bugs introduced in `across()` in previous version (#5765).
+
+* `group_by()` keeps attributes unrelated to the grouping (#5760).
+
+* The `.cols=` argument of `if_any()` and `if_all()` defaults to `everything()`. 
+
 # dplyr 1.0.4
 
 * Improved performance for `across()`. This makes `summarise(across())` and 

R/across.R

@@ -6,7 +6,7 @@
 #' functions like [summarise()] and [mutate()]. See `vignette("colwise")` for
 #'  more details.
 #'
-#' `if_any()` and `if_all()` are used with to apply the same
+#' `if_any()` and `if_all()` apply the same
 #' predicate function to a selection of columns and combine the
 #' results into a single logical vector.
 #'
@@ -147,7 +147,7 @@ across <- function(.cols = everything(), .fns = NULL, ..., .names = NULL) {
 
 #' @rdname across
 #' @export
-if_any <- function(.cols, .fns = NULL, ..., .names = NULL) {
+if_any <- function(.cols = everything(), .fns = NULL, ..., .names = NULL) {
   df <- across({{ .cols }}, .fns = .fns, ..., .names = .names)
   n <- nrow(df)
   df <- vec_cast_common(!!!df, .to = logical())
@@ -156,7 +156,7 @@ if_any <- function(.cols, .fns = NULL, ..., .names = NULL) {
 
 #' @rdname across
 #' @export
-if_all <- function(.cols, .fns = NULL, ..., .names = NULL) {
+if_all <- function(.cols = everything(), .fns = NULL, ..., .names = NULL) {
   df <- across({{ .cols }}, .fns = .fns, ..., .names = .names)
   n <- nrow(df)
   df <- vec_cast_common(!!!df, .to = logical())
@@ -213,7 +213,7 @@ across_setup <- function(cols, fns, names, key, .caller_env) {
   mask <- peek_mask("across()")
   value <- mask$across_cache_get(key)
   if (is.null(value)) {
-    value <- across_setup_impl({{cols}},
+    value <- across_setup_impl({{ cols }},
       fns = fns, names = names, .caller_env = .caller_env, mask = mask,
       .top_level = FALSE
     )
@@ -233,11 +233,10 @@ across_setup_impl <- function(cols, fns, names, .caller_env, mask = peek_mask("a
     #        across_setup() is only ever called on the first group anyway
     #        but perhaps it is time to review how across_cols() work
     mask$set_current_group(1L)
-  } else {
-    # The real `across()` is evaluated in a data mask so we need to remove the
-    # mask layer from the quosure environment (#5460)
-    cols <- quo_set_env(cols, data_mask_top(quo_get_env(cols), recursive = FALSE, inherit = TRUE))
   }
+  # `across()` is evaluated in a data mask so we need to remove the
+  # mask layer from the quosure environment (#5460)
+  cols <- quo_set_env(cols, data_mask_top(quo_get_env(cols), recursive = FALSE, inherit = TRUE))
 
   vars <- tidyselect::eval_select(cols, data = mask$across_cols())
   vars <- names(vars)
@@ -266,21 +265,7 @@ across_setup_impl <- function(cols, fns, names, .caller_env, mask = peek_mask("a
     ))
   }
 
-  expr_protect <- function(x) {
-    call2(quote, x)
-  }
-
-  fns <- map(fns, function(fn) {
-    if (is_formula(fn) && .top_level) {
-      f_rhs(fn) <- call2(
-        quote(rlang::eval_tidy),
-        expr_protect(f_rhs(fn)),
-        data = mask$get_rlang_mask()
-      )
-    }
-    fn <- as_function(fn)
-    fn
-  })
+  fns <- map(fns, as_function)
 
   # make sure fns has names, use number to replace unnamed
   if (is.null(names(fns))) {
@@ -429,7 +414,8 @@ expand_quosure <- function(quo) {
     # call top_across() instead of across()
     quo_env <- quo_get_env(quo)
     quo <- new_quosure(node_poke_car(quo_get_expr(quo), top_across), quo_env)
-    expressions <- eval_tidy(quo)
+    mask <- peek_mask()
+    expressions <- eval_tidy(quo, mask$get_rlang_mask(), mask$get_caller_env())
     names_expressions <- names(expressions)
 
     # process the results of top_across()

R/conditions.R

@@ -6,10 +6,10 @@ arg_name <- function(quos, index) {
   name
 }
 
-cnd_bullet_cur_group_label <- function() {
+cnd_bullet_cur_group_label <- function(what = "error") {
   label <- cur_group_label()
   if (label != "") {
-    glue("The error occurred in {label}.")
+    glue("The {what} occurred in {label}.")
   }
 }
 

R/data-mask.R

@@ -103,7 +103,7 @@ DataMask <- R6Class("DataMask",
     },
 
     set_current_group = function(group) {
-      parent.env(private$chops)$.current_group <- group
+      parent.env(private$chops)$.current_group[] <- group
     },
 
     full_data = function() {
@@ -192,6 +192,10 @@ DataMask <- R6Class("DataMask",
 
     get_rlang_mask = function() {
       private$mask
+    },
+
+    get_caller_env = function() {
+      private$caller
     }
 
   ),

R/deprec-do.r

@@ -138,7 +138,7 @@ do.data.frame <- function(.data, ...) {
   } else {
     out <- map(args, function(arg) list(eval_tidy(arg, mask)))
     names(out) <- names(args)
-    out <- tibble::as_tibble(out, validate = FALSE)
+    out <- tibble::as_tibble(out, .name_repair = "minimal")
   }
 
   out

R/deprec-lazyeval.R

@@ -298,7 +298,7 @@ select_.grouped_df <- function(.data, ..., .dots = list()) {
 select_vars_ <- function(vars, args, include = chr(), exclude = chr()) {
   lifecycle::deprecate_warn("0.7.0", "select_vars_()", "tidyselect::vars_select()")
   args <- compat_lazy_dots(args, caller_env())
-  tidyselect::vars_select(vars, !!!args, include = include, exclude = exclude)
+  tidyselect::vars_select(vars, !!!args, .include = include, .exclude = exclude)
 }
 
 #' @export

R/group-by.r

@@ -149,7 +149,8 @@ group_by_prepare <- function(.data, ..., .add = FALSE, .dots = deprecated(), add
   }
 
   # If any calls, use mutate to add new columns, then group by those
-  computed_columns <- add_computed_columns(ungroup(.data), new_groups, "group_by")
+  computed_columns <- add_computed_columns(.data, new_groups, "group_by")
+
   out <- computed_columns$data
   group_names <- computed_columns$added_names
 
@@ -180,7 +181,7 @@ add_computed_columns <- function(.data, vars, .fn = "group_by") {
     # TODO: use less of a hack
     if (inherits(.data, "data.frame")) {
       cols <- withCallingHandlers(
-        mutate_cols(.data, !!!vars),
+        mutate_cols(ungroup(.data), !!!vars),
         error = function(e) {
           abort(c(
             glue("Problem adding computed columns in `{.fn}()`."),

R/group_map.R

@@ -34,7 +34,7 @@ as_group_map_function <- function(.f) {
 #' @family grouping functions
 #'
 #' @param .data A grouped tibble
-#' @param .f A function or formula to apply to each group. It must return a data frame.
+#' @param .f A function or formula to apply to each group.
 #'
 #'   If a __function__, it is used as is. It should have at least 2 formal arguments.
 #'

R/grouped-df.r

@@ -91,7 +91,8 @@ compute_groups <- function(data, vars, drop = FALSE) {
     groups <- tibble(!!!new_keys, ".rows" := new_rows)
   }
 
-  structure(groups, .drop = drop)
+  attr(groups, ".drop") <- drop
+  groups
 }
 
 count_regroups <- function(code) {

R/mutate.R

@@ -236,7 +236,10 @@ mutate_cols <- function(.data, ...) {
     for (i in seq_along(dots)) {
       mask$across_cache_reset()
 
+      # get results from all the quosures that are expanded from ..i
+      # then ingest them after
       quosures <- expand_quosure(dots[[i]])
+      quosures_results <- vector(mode = "list", length = length(quosures))
 
       for (k in seq_along(quosures)) {
         quo <- quosures[[k]]
@@ -283,11 +286,6 @@ mutate_cols <- function(.data, ...) {
         }
 
         if (is.null(chunks)) {
-          if (quo_data$is_named) {
-            name <- quo_data$name_given
-            new_columns[[name]] <- zap()
-            mask$remove(name)
-          }
           next
         }
 
@@ -305,6 +303,27 @@ mutate_cols <- function(.data, ...) {
           }
         }
 
+        quosures_results[[k]] <- list(result = result, chunks = chunks)
+      }
+
+
+      for (k in seq_along(quosures)) {
+        quo <- quosures[[k]]
+        quo_data <- attr(quo, "dplyr:::data")
+
+        quo_result <- quosures_results[[k]]
+        if (is.null(quo_result)) {
+          if (quo_data$is_named) {
+            name <- quo_data$name_given
+            new_columns[[name]] <- zap()
+            mask$remove(name)
+          }
+          next
+        }
+
+        result <- quo_result$result
+        chunks <- quo_result$chunks
+
         if (!quo_data$is_named && is.data.frame(result)) {
           new_columns[names(result)] <- result
           mask$add_many(result, chunks)
@@ -393,7 +412,7 @@ mutate_cols <- function(.data, ...) {
       cnd_bullet_header(),
       i = conditionMessage(w),
       i = cnd_bullet_input_info(),
-      i = cnd_bullet_cur_group_label()
+      i = cnd_bullet_cur_group_label(what = "warning")
     ))
 
     # Cancel `w`

R/slice.R

@@ -239,7 +239,6 @@ slice_sample.data.frame <- function(.data, ..., n, prop, weight_by = NULL, repla
     n =    function(x, n) sample_int(n, size$n, replace = replace, wt = x),
     prop = function(x, n) sample_int(n, size$prop * n, replace = replace, wt = x),
   )
-
   slice(.data, idx({{ weight_by }}, dplyr::n()))
 }
 
@@ -327,10 +326,13 @@ check_slice_size <- function(n, prop, .slice_fn = "check_slice_size") {
 }
 
 sample_int <- function(n, size, replace = FALSE, wt = NULL) {
-  if (replace) {
-    sample.int(n, size, prob = wt, replace = TRUE)
+  if (!replace) {
+    size <- min(size, n)
+  }
+  if (size == 0L) {
+    integer(0)
   } else {
-    sample.int(n, min(size, n), prob = wt)
+    sample.int(n, size, prob = wt, replace = replace)
   }
 }
 

R/summarise.R

@@ -225,6 +225,7 @@ summarise_cols <- function(.data, ...) {
       mask$across_cache_reset()
 
       quosures <- expand_quosure(dots[[i]])
+      quosures_results <- vector(mode = "list", length = length(quosures))
 
       # with the previous part above, for each element of ... we can
       # have either one or several quosures, each of them handled here:
@@ -246,6 +247,20 @@ summarise_cols <- function(.data, ...) {
         )
         chunks_k <- vec_cast_common(!!!chunks_k, .to = types_k)
 
+        quosures_results[[k]] <- list(chunks = chunks_k, types = types_k)
+      }
+
+      for (k in seq_along(quosures)) {
+        quo <- quosures[[k]]
+        quo_data <- attr(quo, "dplyr:::data")
+
+        quo_result <- quosures_results[[k]]
+        if (is.null(quo_result)) {
+          next
+        }
+        types_k <- quo_result$types
+        chunks_k <- quo_result$chunks
+
         if (!quo_data$is_named && is.data.frame(types_k)) {
           chunks_extracted <- .Call(dplyr_extract_chunks, chunks_k, types_k)