document and more tests

Author: lorenzwalthert

R/nest.R

@@ -63,7 +63,7 @@ add_cache_block <- function(pd_nested) {
 #' level token. For that
 #' reason, the nested parse table can, at the rows where these expressions are
 #' located, be shallow, i.e. it does not have to contain a child, because it
-#' will neither be transformed nor serialized anytime. This function drop all
+#' will neither be transformed nor serialized anytime. This function drops all
 #' associated tokens except the top-level token for such expressions, which will
 #' result in large speed improvements in [compute_parse_data_nested()] because
 #' nesting is expensive and will not be done for cached expressions.

R/relevel.R

@@ -183,7 +183,10 @@ relocate_eq_assign_nest <- function(pd) {
 #' Two assignment tokens `EQ_ASSIGN` belong to the same block if they are not
 #' separated by more than one token. Token between `EQ_ASSIGN` tokens belong
 #' to the `EQ_ASSIGN` token occurring before them, except the token right before
-#' `EQ_ASSING` already belongs to the `EQ_ASSING` after it.
+#' `EQ_ASSING` already belongs to the `EQ_ASSING` after it. Note that this
+#' notion is unrelated to the column *block* in the parse table, which is used
+#' to [parse_transform_serialize_r()] code blocks and leave out the ones that
+#' are cached.
 #' @param pd A parse table.
 #' @keywords internal
 find_block_id <- function(pd) {

R/transform-block.R

@@ -79,19 +79,18 @@ cache_find_block <- function(pd) {
 #' @return The line number on which the first token occurs.
 #' @keywords internal
 find_blank_lines_to_next_expr <- function(pd_nested) {
-  # TODO think about naming: prefix with cache here also or just ui functions?
   pd_nested$line1 - lag(pd_nested$line2, default = 0)
 }
 
 #' Number of lines between cache blocks
 #'
 #' This is relevant when putting expressions together into a block and preserve
-#' blank lines between them.
+#' blank lines between them. Note that because code does not need to start on
+#' line 1, the first element of the output is the number of lines until the
+#' first block.
 #' @param pd A top level nest.
 find_blank_lines_to_next_block <- function(pd) {
   block_boundary <- pd$block != lag(pd$block, default = 0)
-  # TODO everywhere: block is ambiguous. use cache block since we also have
-  # block_id and other things in other places
   find_blank_lines_to_next_expr(pd)[block_boundary]
 }
 

R/transform-files.R

@@ -92,8 +92,6 @@ make_transformer <- function(transformers,
     }
 
     if (!use_cache) {
-      # TODO just info: if the whole expression is in the cache, don't even
-      # compute the parse data nested
       transformed_code <- text %>%
         parse_transform_serialize_r(transformers, warn_empty = warn_empty) %>%
         when(

man/drop_cached_children.Rd

@@ -1,4 +1,5 @@
 test_that("caching utils make right blocks with semi-colon", {
+
   blocks_simple_uncached <- compute_parse_data_nested(c("1 + 1", "2; 1+1")) %>%
     dplyr::mutate(is_cached = FALSE) %>%
     cache_find_block()
@@ -15,6 +16,45 @@ test_that("caching utils make right blocks with semi-colon", {
   expect_equal(blocks_edge, c(1, 2, 2, 2))
 })
 
+test_that("blank lines are correctly identified", {
+  on.exit(clear_testthat_cache())
+  clear_testthat_cache()
+  activate_testthat_cache()
+  text <- c(
+    "1 + 1",
+    "",
+    "",
+    "f(x)",
+    "",
+    "",
+    "",
+    "x < 3",
+    "function() NULL"
+  )
+  # when not cached, all code in same block
+  pd_nested <- compute_parse_data_nested(text, tidyverse_style())
+  cache_by_expression(text, tidyverse_style())
+  expect_equal(
+    pd_nested$block, rep(1, 4)
+  )
+
+  expect_equal(
+    find_blank_lines_to_next_block(pd_nested),
+    1
+  )
+
+  # when partly cached, not all code in same block
+  text[4] <- "f (x)"
+  pd_nested <- compute_parse_data_nested(text, tidyverse_style())
+  expect_equal(
+    pd_nested$block, c(1, 2, 3, 3)
+  )
+
+  expect_equal(
+    find_blank_lines_to_next_block(pd_nested),
+    c(1, 3, 4)
+  )
+})
 
 test_that("caching utils make right blocks with comments", {
   blocks_simple_uncached <- compute_parse_data_nested(c("1 + 1", "2 # comment")) %>%