Convert from lazyeval to tidy eval (#55)

And include many more test from dplyr.

Fixes #17. Fixes #43. Fixes #51. Fixes #54.

DESCRIPTION

@@ -11,8 +11,8 @@ Description: This implements the data table back-end for 'dplyr' so that you
 License: GPL (>= 2)
 Imports:
     dplyr (>= 0.5.0),
+    tidyselect,
     data.table (>= 1.9.6),
-    lazyeval,
     rlang
 Suggests:
     Lahman,
@@ -21,5 +21,6 @@ Suggests:
     covr
 LazyData: true
 RoxygenNote: 6.1.1
+Encoding: UTF-8
 URL: https://github.com/hadley/dtplyr
 BugReports: https://github.com/hadley/dtplyr/issues

NAMESPACE

@@ -25,21 +25,25 @@ export(src_dt)
 export(tbl_dt)
 import(rlang)
 importFrom(data.table,as.data.table)
-importFrom(dplyr,arrange_)
+importFrom(dplyr,arrange)
 importFrom(dplyr,as.tbl)
 importFrom(dplyr,auto_copy)
-importFrom(dplyr,distinct_)
-importFrom(dplyr,do_)
-importFrom(dplyr,filter_)
-importFrom(dplyr,group_by_)
+importFrom(dplyr,distinct)
+importFrom(dplyr,do)
+importFrom(dplyr,filter)
+importFrom(dplyr,group_by)
+importFrom(dplyr,group_by_prepare)
+importFrom(dplyr,group_vars)
 importFrom(dplyr,groups)
-importFrom(dplyr,mutate_)
-importFrom(dplyr,rename_)
+importFrom(dplyr,mutate)
+importFrom(dplyr,rename)
 importFrom(dplyr,same_src)
-importFrom(dplyr,select_)
-importFrom(dplyr,slice_)
-importFrom(dplyr,summarise_)
+importFrom(dplyr,select)
+importFrom(dplyr,slice)
+importFrom(dplyr,summarise)
 importFrom(dplyr,tbl_vars)
 importFrom(dplyr,ungroup)
+importFrom(tidyselect,vars_rename)
+importFrom(tidyselect,vars_select)
 importFrom(utils,head)
 importFrom(utils,tail)

NEWS.md

@@ -1,6 +1,13 @@
-
 # dtplyr 0.0.3.9000
 
+* Convert from lazyeval to tidy eval (@christophsax).
+
+* `ungroup()` now copies it's input (@christophsax, #54).
+
+* Scoped verbs now work (@christophsax, #43, #51).
+
+* `mutate()` preserves grouping (@christophsax, #17).
+
 # dtplyr 0.0.3
 
 - Maintenance release for CRAN checks.

R/compat-dplyr-0.6.0.R

@@ -13,18 +13,18 @@
     register_s3_method("dplyr", "slice", "data.table")
   }
 
-  register_s3_method("dplyr", "do_", "data.table")
-  register_s3_method("dplyr", "do_", "tbl_dt")
+  register_s3_method("dplyr", "do", "data.table")
+  register_s3_method("dplyr", "do", "tbl_dt")
 
   register_s3_method("base", "print", "grouped_dt")
   register_s3_method("dplyr", "groups", "grouped_dt")
   register_s3_method("dplyr", "group_size", "grouped_dt")
   register_s3_method("dplyr", "n_groups", "grouped_dt")
   register_s3_method("dplyr", "ungroup", "grouped_dt")
 
-  register_s3_method("dplyr", "group_by_", "data.table")
-  register_s3_method("dplyr", "do_", "grouped_dt")
-  register_s3_method("dplyr", "distinct_", "grouped_dt")
+  register_s3_method("dplyr", "group_by", "data.table")
+  register_s3_method("dplyr", "do", "grouped_dt")
+  register_s3_method("dplyr", "distinct", "grouped_dt")
 
   register_s3_method("dplyr", "inner_join", "data.table")
   register_s3_method("dplyr", "left_join", "data.table")
@@ -38,36 +38,36 @@
   register_s3_method("dplyr", "sample_frac", "tbl_dt")
   register_s3_method("dplyr", "sample_frac", "grouped_dt")
 
-  register_s3_method("dplyr", "distinct_", "data.table")
-  register_s3_method("dplyr", "distinct_", "tbl_dt")
+  register_s3_method("dplyr", "distinct", "data.table")
+  register_s3_method("dplyr", "distinct", "tbl_dt")
 
-  register_s3_method("dplyr", "filter_", "grouped_dt")
-  register_s3_method("dplyr", "filter_", "tbl_dt")
-  register_s3_method("dplyr", "filter_", "data.table")
+  register_s3_method("dplyr", "filter", "grouped_dt")
+  register_s3_method("dplyr", "filter", "tbl_dt")
+  register_s3_method("dplyr", "filter", "data.table")
 
-  register_s3_method("dplyr", "summarise_", "grouped_dt")
-  register_s3_method("dplyr", "summarise_", "tbl_dt")
-  register_s3_method("dplyr", "summarise_", "data.table")
+  register_s3_method("dplyr", "summarise", "grouped_dt")
+  register_s3_method("dplyr", "summarise", "tbl_dt")
+  register_s3_method("dplyr", "summarise", "data.table")
 
-  register_s3_method("dplyr", "mutate_", "grouped_dt")
-  register_s3_method("dplyr", "mutate_", "tbl_dt")
-  register_s3_method("dplyr", "mutate_", "data.table")
+  register_s3_method("dplyr", "mutate", "grouped_dt")
+  register_s3_method("dplyr", "mutate", "tbl_dt")
+  register_s3_method("dplyr", "mutate", "data.table")
 
-  register_s3_method("dplyr", "arrange_", "grouped_dt")
-  register_s3_method("dplyr", "arrange_", "tbl_dt")
-  register_s3_method("dplyr", "arrange_", "data.table")
+  register_s3_method("dplyr", "arrange", "grouped_dt")
+  register_s3_method("dplyr", "arrange", "tbl_dt")
+  register_s3_method("dplyr", "arrange", "data.table")
 
-  register_s3_method("dplyr", "select_", "grouped_dt")
-  register_s3_method("dplyr", "select_", "tbl_dt")
-  register_s3_method("dplyr", "select_", "data.table")
+  register_s3_method("dplyr", "select", "grouped_dt")
+  register_s3_method("dplyr", "select", "tbl_dt")
+  register_s3_method("dplyr", "select", "data.table")
 
-  register_s3_method("dplyr", "rename_", "grouped_dt")
-  register_s3_method("dplyr", "rename_", "tbl_dt")
-  register_s3_method("dplyr", "rename_", "data.table")
+  register_s3_method("dplyr", "rename", "grouped_dt")
+  register_s3_method("dplyr", "rename", "tbl_dt")
+  register_s3_method("dplyr", "rename", "data.table")
 
-  register_s3_method("dplyr", "slice_", "grouped_dt")
-  register_s3_method("dplyr", "slice_", "tbl_dt")
-  register_s3_method("dplyr", "slice_", "data.table")
+  register_s3_method("dplyr", "slice", "grouped_dt")
+  register_s3_method("dplyr", "slice", "tbl_dt")
+  register_s3_method("dplyr", "slice", "data.table")
 
   invisible()
 }

R/do.R

@@ -3,16 +3,12 @@
 #'   importFrom(dplyr,do)
 #'   S3method(do,data.table)
 #' }
+#' @importFrom dplyr do
 do.data.table <- function(.data, ...) {
-  do_(.data, .dots = lazyeval::lazy_dots(...))
-}
-
-#' @importFrom dplyr do_
-do_.data.table <- function(.data, ..., .dots) {
-  out <- do_(as.data.frame(.data), ..., .dots = .dots)
+  out <- do(as.data.frame(.data), !!! quos(...))
   data.table::as.data.table(out)
 }
-do_.tbl_dt <- function(.data, ..., .dots) {
-  out <- do_(as.data.frame(.data), ..., .dots = .dots)
+do.tbl_dt <- function(.data, ...) {
+  out <- do(as.data.frame(.data), !!! quos(...))
   tbl_dt(out)
 }

R/grouped-dt.r

@@ -64,34 +64,35 @@ n_groups.grouped_dt <- function(x) {
   nrow(dt_subset(x, , quote(list(1))))
 }
 
-#' @importFrom dplyr group_by_
+#' @importFrom dplyr group_by group_by_prepare group_vars
 group_by.data.table <- function(.data, ..., add = FALSE) {
-  group_by_(.data, .dots = lazyeval::lazy_dots(...), add = add)
-}
-group_by_.data.table <- function(.data, ..., .dots, add = FALSE) {
-  groups <- dplyr::group_by_prepare(.data, ..., .dots = .dots, add = add)
+  groups <- group_by_prepare(.data, ..., add = add)
   grouped_dt(groups$data, groups$groups)
+  # groups <- dplyr::group_by_prepare(.data, ..., .dots = .dots, add = add)
+  # grouped_dt(groups$data, groups$groups)
 }
 
 ungroup.grouped_dt <- function(x, ...) {
-  data.table::setattr(x, "vars", NULL)
-  data.table::setattr(x, "class", setdiff(class(x), "grouped_dt"))
-  x
+  z <- data.table::copy(x)
+  data.table::setattr(z, "vars", NULL)
+  data.table::setattr(z, "class", setdiff(class(z), "grouped_dt"))
+  z
 }
 
 
 # Do ---------------------------------------------------------------------------
 
-do_.grouped_dt <- function(.data, ..., .dots) {
-  args <- lazyeval::all_dots(.dots, ...)
-  env <- lazyeval::common_env(args)
-  named <- named_args(args)
+do.grouped_dt <- function(.data, ...) {
+
+  dots <- quos(...)
+  env <- common_env(dots)
+  named <- named_args(dots)
 
   if (!named) {
-    j <- args[[1]]$expr
+    j <- get_expr(dots[[1]])
   } else {
-    args <- lapply(args, function(x) call("list", x$expr))
-    j <- as.call(c(quote(list), args))
+    exprs <- lapply(dots, function(x) call("list", get_expr(x)))
+    j <- as.call(c(quote(list), exprs))
   }
 
   out <- dt_subset(.data, , j, env = env, sd_cols = names(.data))
@@ -125,9 +126,9 @@ named_args <- function(args) {
 
 # Set operations ---------------------------------------------------------------
 
-distinct_.grouped_dt <- function(.data, ..., .dots) {
-  groups <- lazyeval::as.lazy_dots(groups(.data))
-  dist <- distinct_vars(.data, ..., .dots = c(.dots, groups))
+distinct.grouped_dt <- function(.data, ...) {
+
+  dist <- distinct_vars(.data, quos(!!!groups(.data), ..., .named = TRUE))
 
   grouped_dt(unique(dist$data, by = dist$vars), groups(.data), copy = FALSE)
 }

R/sets.R

@@ -1,13 +1,9 @@
 
 # Set operations ---------------------------------------------------------------
 
-distinct.data.table <- function(.data, ..., .keep_all = FALSE) {
-  distinct_(.data, .dots = lazyeval::lazy_dots(...), .keep_all = .keep_all)
-}
-
-#' @importFrom dplyr distinct_
-distinct_.data.table <- function(.data, ..., .dots, .keep_all = FALSE) {
-  dist <- distinct_vars(.data, ..., .dots = .dots)
+#' @importFrom dplyr distinct
+distinct.data.table <- function(.data, ..., .dots, .keep_all = FALSE) {
+  dist <- distinct_vars(.data, quos(..., .named = TRUE), .keep_all = .keep_all)
 
   if (length(dist$vars) == 0) {
     res <- unique(dist$data, by = NULL)
@@ -21,21 +17,38 @@ distinct_.data.table <- function(.data, ..., .dots, .keep_all = FALSE) {
 
   res
 }
-distinct_.tbl_dt <- function(.data, ..., .dots) {
+distinct.tbl_dt <- function(.data, ...) {
   tbl_dt(NextMethod(), copy = FALSE)
 }
 
-distinct_vars <- function(.data, ..., .dots) {
-  dots <- lazyeval::all_dots(.dots, ..., all_named = TRUE)
+# unexported from dplyr, removed purrr dependency
+distinct_vars <- function(.data, vars, group_vars = character(), .keep_all = FALSE) {
+  stopifnot(is_quosures(vars), is.character(group_vars))
+
+  # If no input, keep all variables
+  if (length(vars) == 0) {
+    return(list(
+      data = .data,
+      vars = names(.data),
+      keep = names(.data)
+    ))
+  }
 
   # If any calls, use mutate to add new columns, then distinct on those
-  needs_mutate <- vapply(dots, function(x) !is.name(x$expr), logical(1))
+  needs_mutate <- vapply(vars, quo_is_lang, TRUE)
   if (any(needs_mutate)) {
-    .data <- mutate_(.data, .dots = dots[needs_mutate])
+    .data <- mutate(.data, !!! vars[needs_mutate])
   }
 
   # Once we've done the mutate, we no longer need lazy objects, and
   # can instead just use their names
-  list(data = .data, vars = names(dots))
-}
+  out_vars <- intersect(names(.data), c(names(vars), group_vars))
 
+  if (.keep_all) {
+    keep <- names(.data)
+  } else {
+    keep <- unique(out_vars)
+  }
+
+  list(data = .data, vars = out_vars, keep = keep)
+}