Update docs and adds tests for Quarto files (#1487)

* Updates docs and adds tests for Quarto files

Closes #1486

* Update get_source_expressions.Rd

* Update test-trailing_blank_lines_linter.R

* Update test-trailing_blank_lines_linter.R

* Update test-trailing_blank_lines_linter.R

* comment out the offending test example

* Update NEWS and remove lint

* Update test.qmd

* get rid of lints and style

Co-authored-by: Michael Chirico <[email protected]>

Author: IndrajeetPatil

NEWS.md

@@ -91,7 +91,9 @@
 * The minimum needed version for soft dependency `{withr}` has been bumped to `2.5.0`
   (#1404, @IndrajeetPatil).
 * Changed the deprecation warning for `with_defaults()` to also mention `modify_defaults()` (#1438, @AshesITR).
-
+* Quarto files (`.qmd`) were supported out of the box. The documentation and the 
+  testing infrastructure are updated to reflect this (#1486, @IndrajeetPatil).
+  
 # lintr 3.0.0
 
 ## Breaking changes

R/extract.R

@@ -69,7 +69,7 @@ filter_chunk_start_positions <- function(starts, lines) {
 filter_chunk_end_positions <- function(starts, ends) {
   # In a valid file, possibly with plain-code-blocks,
   # - there should be at least as many ends as starts
-  # In Rmarkdown, unevaluated blocks may open & close with the same ``` pattern
+  # In Rmarkdown and Quarto, unevaluated blocks may open & close with the same ``` pattern
   # that defines the end-pattern for an evaluated block
 
   # This returns the first end-position that succeeds each start-position

R/get_source_expressions.R

@@ -39,7 +39,7 @@
 #'     \item{`filename` (`character`)}
 #'     \item{`file_lines` (`character`) the [readLines()] output for this file}
 #'     \item{`content` (`character`) for .R files, the same as `file_lines`;
-#'           for .Rmd scripts, this is the extracted R source code (as text)}
+#'           for .Rmd or .qmd scripts, this is the extracted R source code (as text)}
 #'     \item{`full_parsed_content` (`data.frame`) as given by
 #'           [utils::getParseData()] for the full content}
 #'     \item{`full_xml_parsed_content` (`xml_document`) the XML parse tree of all

R/lint.R

@@ -119,8 +119,8 @@ lint <- function(filename, linters = NULL, ..., cache = FALSE, parse_settings =
 #' @param relative_path if `TRUE`, file paths are printed using their path relative to the base directory.
 #'   If `FALSE`, use the full absolute path.
 #' @param exclusions exclusions for [exclude()], relative to the package path.
-#' @param pattern pattern for files, by default it will take files with any of the extensions .R, .Rmd, .Rnw, .Rhtml,
-#' .Rrst, .Rtex, .Rtxt allowing for lowercase r (.r, ...)
+#' @param pattern pattern for files, by default it will take files with any of the extensions
+#' .R, .Rmd, .qmd, .Rnw, .Rhtml, .Rrst, .Rtex, .Rtxt allowing for lowercase r (.r, ...)
 #' @examples
 #' \dontrun{
 #'   lint_dir()

man/get_source_expressions.Rd

@@ -0,0 +1,80 @@
+# Test #
+
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod
+tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At
+vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,
+no sea takimata sanctus est Lorem ipsum dolor sit amet.
+
+```{r}
+a = 1
+```
+
+Test
+====
+
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod
+tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At
+vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,
+no sea takimata sanctus est Lorem ipsum dolor sit amet.
+
+```{r}
+b <- function(x) {
+  d = 1
+}
+
+```
+
+```{r engine="python"}
+a=[]
+
+a[0]=1
+```
+
+```
+Plain code blocks can be written after three or more backticks
+- R Markdown: The Definitive Guide. Xie, Allaire and Grolemund (2.5.2)
+```
+
+```r
+# This is a non-evaluated block of R code for formatting in markdown.
+# It should not be linted
+abc = 123
+```
+
+```cpp
+// Some C++ code for formatting by markdown
+
+```
+
+Calls to a non-R knitr-engine using {engine_name} syntax.
+
+```{python}
+# Python that looks like R
+a = list()
+b = {2}
+print(a)
+```
+
+```{python}
+# Python that's definitely not R
+a = []
+a.append(2)
+print(a)
+```
+
+The following are only supported by Quarto and shouldn't lint either.
+
+```{.r}
+1+1
+```
+
+```{{r}}
+1+1
+```
+
+```{.python}
+# Python that's definitely not R
+a = []
+a.append(2)
+print(a)
+```

man/lint.Rd

@@ -0,0 +1,14 @@
+# Test #
+
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod
+tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At
+vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,
+no sea takimata sanctus est Lorem ipsum dolor sit amet.
+
+```{r}
+a = 1
+
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod
+tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At
+vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,
+no sea takimata sanctus est Lorem ipsum dolor sit amet.

tests/testthat/knitr_formats/test.qmd

@@ -12,18 +12,22 @@ with_content_to_parse <- function(content, code) {
 }
 
 test_that("tab positions have been corrected", {
-  with_content_to_parse("1\n\t",
+  with_content_to_parse(
+    "1\n\t",
     expect_length(pc, 2L)
   )
 
-  with_content_to_parse("TRUE",
+  with_content_to_parse(
+    "TRUE",
     expect_identical(unlist(pc[[1L]][pc[[1L]][["text"]] == "TRUE", c("col1", "col2")], use.names = FALSE), c(1L, 4L))
   )
-  with_content_to_parse("\tTRUE",
+  with_content_to_parse(
+    "\tTRUE",
     expect_identical(unlist(pc[[1L]][pc[[1L]][["text"]] == "TRUE", c("col1", "col2")], use.names = FALSE), c(2L, 5L))
   )
 
-  with_content_to_parse("\t\tTRUE",
+  with_content_to_parse(
+    "\t\tTRUE",
     expect_identical(unlist(pc[[1L]][pc[[1L]][["text"]] == "TRUE", c("col1", "col2")], use.names = FALSE), c(3L, 6L))
   )
 
@@ -83,7 +87,7 @@ test_that("Multi-byte characters correct columns", {
 
   with_content_to_parse("`\U2020` <- 1", {
     # fix_column_numbers corrects the start of <-
-    expect_equal(pc[[1L]]$col1[4L], pc[[1L]]$col1[2L] + 4L)
+    expect_identical(pc[[1L]]$col1[4L], pc[[1L]]$col1[2L] + 4L)
   })
 })
 
@@ -92,8 +96,8 @@ test_that("Multi-byte character truncated by parser is ignored", {
   # \U2013 is the Unicode character 'en dash', which is
   # almost identical to a minus sign in monospaced fonts.
   with_content_to_parse("y <- x \U2013 42", {
-    expect_equal(error$message, "unexpected input")
-    expect_equal(error$column_number, 8L)
+    expect_identical(error$message, "unexpected input")
+    expect_identical(error$column_number, 8L)
   })
 })
 
@@ -117,17 +121,17 @@ test_that("Warns if encoding is misspecified", {
     msg <- "unexpected '<'"
   }
 
-  expect_equal(the_lint$linter, "error")
-  expect_equal(the_lint$message, msg)
-  expect_equal(the_lint$line_number, 4L)
+  expect_identical(the_lint$linter, "error")
+  expect_identical(the_lint$message, msg)
+  expect_identical(the_lint$line_number, 4L)
 
   file <- test_path("dummy_projects", "project", "cp1252_parseable.R")
   read_settings(NULL)
   the_lint <- lint(filename = file, parse_settings = FALSE)[[1L]]
   expect_s3_class(the_lint, "lint")
-  expect_equal(the_lint$linter, "error")
-  expect_equal(the_lint$message, "Invalid multibyte string. Is the encoding correct?")
-  expect_equal(the_lint$line_number, 1L)
+  expect_identical(the_lint$linter, "error")
+  expect_identical(the_lint$message, "Invalid multibyte string. Is the encoding correct?")
+  expect_identical(the_lint$line_number, 1L)
 })
 
 test_that("Can extract line number from parser errors", {
@@ -138,38 +142,44 @@ test_that("Can extract line number from parser errors", {
     trim_some('
       "ok"
       R"---a---"
-    '), {
-    expect_equal(error$message, "Malformed raw string literal.")
-    expect_equal(error$line_number, 2L)
-  })
+    '),
+    {
+      expect_identical(error$message, "Malformed raw string literal.")
+      expect_identical(error$line_number, 2L)
+    }
+  )
 
   # invalid \u{xxxx} sequence (line 3)
   with_content_to_parse(
     trim_some('
       ok
       ok
       "\\u{9999"
-    '), {
-    expect_equal(error$message, "Invalid \\u{xxxx} sequence.")
-    expect_equal(error$line_number, 3L)
-  })
+    '),
+    {
+      expect_identical(error$message, "Invalid \\u{xxxx} sequence.")
+      expect_identical(error$line_number, 3L)
+    }
+  )
 
   # invalid \u{xxxx} sequence (line 4)
   with_content_to_parse(
     trim_some('
       ok
       ok
       "\\u{9999
-    '), {
-    # parser erroneously reports line 4
-    expect_equal(error$message, "Invalid \\u{xxxx} sequence.")
-    expect_equal(error$line_number, 3L)
-  })
+    '),
+    {
+      # parser erroneously reports line 4
+      expect_identical(error$message, "Invalid \\u{xxxx} sequence.")
+      expect_identical(error$line_number, 3L)
+    }
+  )
 
   # repeated formal argument 'a' on line 1
   with_content_to_parse("function(a, a) {}", {
-    expect_equal(error$message, "Repeated formal argument 'a'.")
-    expect_equal(error$line_number, 1L)
+    expect_identical(error$message, "Repeated formal argument 'a'.")
+    expect_identical(error$line_number, 1L)
   })
 })
 
@@ -235,8 +245,10 @@ test_that("returned data structure is complete", {
   expect_identical(full_expr$file_lines, lines_with_attr)
   expect_identical(full_expr$content, lines_with_attr)
   expect_identical(nrow(full_expr$full_parsed_content), 2L * length(lines))
-  expect_identical(xml2::xml_find_num(full_expr$full_xml_parsed_content, "count(//SYMBOL)"),
-                    as.numeric(length(lines)))
+  expect_identical(
+    xml2::xml_find_num(full_expr$full_xml_parsed_content, "count(//SYMBOL)"),
+    as.numeric(length(lines))
+  )
   expect_true(full_expr$terminal_newline)
 
   expect_null(exprs$error)
@@ -284,7 +296,7 @@ test_that("#743, #879, #1406: get_source_expressions works on R files matching a
   expect_null(source_expressions$error)
 })
 
-test_that("Syntax errors in Rmd don't choke lintr", {
+test_that("Syntax errors in Rmd or qmd don't choke lintr", {
   tmp <- withr::local_tempfile(lines = c(
     "```{r}",
     "if (TRUE) {",
@@ -321,7 +333,7 @@ param_df <- expand.grid(
   stringsAsFactors = FALSE
 )
 param_df$.test_name <-
- with(param_df, sprintf("%s on expression %d", linter, expression_idx))
+  with(param_df, sprintf("%s on expression %d", linter, expression_idx))
 
 patrick::with_parameters_test_that(
   "linters pass with xml_missing() content",