Merge pull request #313 from lorenzwalthert/fun-dec

- Only consider R code as code to format (#313).

Author: lorenzwalthert

R/transform-code.R

@@ -29,48 +29,79 @@ transform_code <- function(path, fun, verbose = FALSE, ...) {
 #' @param transformer_fun A styler transformer function
 #' @importFrom purrr flatten_chr
 transform_rmd <- function(lines, transformer_fun) {
-  chunks <- identify_chunks(lines)
+  chunks <- separate_chunks(lines)
   chunks$r_chunks <- map(chunks$r_chunks, transformer_fun)
 
   map2(chunks$text_chunks, c(chunks$r_chunks, list(character(0))), c) %>%
     flatten_chr()
 }
 
 
-#' Identify chunks within Rmd contents
-#'
-#' Identifies the code and text chunks within an Rmd file, and returns these
-#' as a nested list.
+#' Separate chunks within Rmd contents
 #'
+#' Identifies and separates the code and text chunks (the latter includes non-R
+#' code) within an Rmd file, and returns these separately.
 #' @param lines a character vector of lines from an Rmd file
-#'
 #' @importFrom purrr map2
 #' @importFrom rlang seq2
-identify_chunks <- function(lines) {
+separate_chunks <- function(lines) {
+  r_raw_chunks <- identify_r_raw_chunks(lines)
+  r_chunks <- map2(
+    r_raw_chunks$starts, r_raw_chunks$ends, ~lines[seq2(.x + 1, .y - 1)]
+  )
+
+  text_chunks <- map2(
+    c(1, r_raw_chunks$ends), c(r_raw_chunks$starts, length(lines)),
+    ~lines[seq2(.x, .y)]
+  )
+  lst(r_chunks, text_chunks)
+}
+
+#' Identifies raw R code chunks
+#'
+#' Raw in the sense that these chunks don't contain pure R code, but they
+#' contain a header and footer of markdown. Only code chunks that have an engine
+#' whose name matches `engine-pattern` are considered as R code.
+#' @inheritParams separate_chunks
+#' @param engine_pattern A regular expression that must match the engine name.
+identify_r_raw_chunks <- function(lines, engine_pattern = get_engine_pattern()) {
   pattern <- get_knitr_pattern(lines)
   if (is.null(pattern$chunk.begin) || is.null(pattern$chunk.end)) {
     stop("Unrecognized chunk pattern!", call. = FALSE)
   }
-
-  starts <- grep(pattern$chunk.begin, lines, perl = TRUE)
-  ends <- grep(pattern$chunk.end, lines, perl = TRUE)
+  starts <- grep("^[\t >]*```+\\s*\\{\\s*([a-zA-Z0-9]+.*)\\}\\s*$", lines, perl = TRUE)
+  ends <- grep("^[\t >]*```+\\s*$", lines, perl = TRUE)
 
   if (length(starts) != length(ends)) {
     stop("Malformed file!", call. = FALSE)
   }
 
-  r_chunks <- map2(starts, ends, ~lines[seq2(.x + 1, .y - 1)])
-
-  text_chunks <- map2(c(1, ends), c(starts, length(lines)), ~lines[seq2(.x, .y)])
+  is_r_code <- grepl(
+    paste0("^[\t >]*```+\\s*\\{\\s*", engine_pattern, "[\\s\\},]"),
+    lines[starts], perl = TRUE
+  )
+  list(starts = starts[is_r_code], ends = ends[is_r_code])
+}
 
-  lst(r_chunks, text_chunks)
+#' What's the engine pattern for rmd code chunks?
+#'
+#' The function returns the regular expression pattern that identifies
+#' all r engines in Rmd chunks. Defaults to `[Rr]`. You probably only want to
+#' change this if you create a knitr engine that processes R code but is not
+#' the default engine `r`.
+#' The pattern must be followed by a space (in the case the chunk is given
+#' a name), a comma (if no name is given but further options are passed to the
+#' engine) or a closing curly brace (in case no option and no name is given to
+#' the chunk).
+get_engine_pattern <- function() {
+  "[rR]"
 }
 
 #' Get chunk pattern
 #'
 #' Determine a regex pattern for identifying R code chunks.
 #'
-#' @inheritParams identify_chunks
+#' @inheritParams separate_chunks
 get_knitr_pattern <- function(lines) {
   knitr::all_patterns[["md"]]
 }

man/get_engine_pattern.Rd

@@ -7,7 +7,7 @@ Some text before empty chunk
 ```
 Final text before longer code chunk
 This text chunk has multiple lines
-```{r}
+```{R}
 # random
 this(is_a_call(x))
 if (x) {

man/identify_chunks.Rd

@@ -0,0 +1,30 @@
+# Header
+
+Some text.
+
+```{R}
+1+1
+```
+
+```{r}
+1+1
+```
+
+```{r, a = 3}
+1+1
+```
+
+```{ r }
+1+1
+```
+
+More text.
+
+```{nonR}
+I like the jungle, I like the .2'
+```
+
+```{blabla }
+I like the jungle,
+```
+

man/identify_r_raw_chunks.Rd

@@ -0,0 +1,30 @@
+# Header
+
+Some text.
+
+```{R}
+1 + 1
+```
+
+```{r}
+1 + 1
+```
+
+```{r, a = 3}
+1 + 1
+```
+
+```{ r }
+1 + 1
+```
+
+More text.
+
+```{nonR}
+I like the jungle, I like the .2'
+```
+
+```{blabla }
+I like the jungle,
+```
+

man/separate_chunks.Rd

@@ -1,10 +1,16 @@
 context("rmd")
 
 test_that("can style .Rmd files", {
-  test_collection(
-    "rmd",
+  expect_error(test_collection(
+    "rmd", "simple",
     transformer = transform_rmd,
     transformer_fun = style_text,
     write_tree = FALSE
-  )
+  ), NA)
+  expect_error(test_collection(
+    "rmd", "r_and_non_r_code_chunks",
+    transformer = transform_rmd,
+    transformer_fun = style_text,
+    write_tree = FALSE
+  ), NA)
 })