re_matches_logical helper ensures logical output of re_matches_logical

R/expect_lint.R

@@ -105,16 +105,10 @@ expect_lint <- function(content, checks, ..., file = NULL, language = "en") {
           )
           # deparse ensures that NULL, list(), etc are handled gracefully
           ok <- if (field == "message") {
-            re_matches(value, check)
+            re_matches_logical(value, check)
           } else {
             isTRUE(all.equal(value, check))
           }
-          if (!is.logical(ok)) {
-            cli_abort(c(
-              x = "Invalid regex result. Did you mistakenly have a capture group in the regex?",
-              i = "You can match parentheses with a character class, i.e. inside `[]`."
-            ))
-          }
           testthat::expect(ok, msg)
         })
       },

R/lintr-package.R

@@ -11,7 +11,7 @@
 #' @importFrom cli cli_inform cli_abort cli_warn
 #' @importFrom glue glue glue_collapse
 #' @importFrom rex rex regex re_matches re_substitutes character_class
-#' @importFrom stats na.omit
+#' @importFrom stats complete.cases na.omit
 #' @importFrom tools R_user_dir
 #' @importFrom utils capture.output getParseData getTxtProgressBar globalVariables head relist
 #'   setTxtProgressBar tail txtProgressBar

R/object_name_linter.R

@@ -146,13 +146,8 @@ object_name_linter <- function(styles = c("snake_case", "symbols"), regexes = ch
 }
 
 check_style <- function(nms, style, generics = character()) {
-  conforming <- re_matches(nms, style)
+  conforming <- re_matches_logical(nms, style)
 
-  # style has capture group(s)
-  if (is.data.frame(conforming)) {
-    # if any group is missing, all groups are missing, so just check the first column
-    conforming <- !is.na(conforming[[1L]])
-  }
   # mark empty or NA names as conforming
   conforming <- is.na(nms) | !nzchar(nms) | conforming
 

R/return_linter.R

@@ -147,7 +147,8 @@ return_linter <- function(
     xml <- source_expression$xml_parsed_content
     if (defer_except) {
       assigned_functions <- xml_text(xml_find_all(xml, function_name_xpath))
-      except <- union(except, assigned_functions[re_matches(assigned_functions, except_regex)])
+      except <-
+        union(except, assigned_functions[re_matches_logical(assigned_functions, except_regex)])
       except_xpath <- glue(except_xpath_fmt, except = except)
       body_xpath <- glue(body_xpath_fmt, except_xpath = except_xpath)
     }

R/todo_comment_linter.R

@@ -57,9 +57,9 @@ todo_comment_linter <- function(todo = c("todo", "fixme"), except_regex = NULL)
 
     comment_expr <- xml_find_all(xml, "//COMMENT")
     comment_text <- xml_text(comment_expr)
-    invalid_todo <- re_matches(comment_text, todo_comment_regex, ignore.case = TRUE)
+    invalid_todo <- re_matches_logical(comment_text, todo_comment_regex, ignore.case = TRUE)
     if (!is.null(valid_todo_regex)) {
-      invalid_todo <- invalid_todo & !re_matches(comment_text, valid_todo_regex)
+      invalid_todo <- invalid_todo & !re_matches_logical(comment_text, valid_todo_regex)
     }
 
     xml_nodes_to_lints(

R/unreachable_code_linter.R

@@ -130,7 +130,7 @@ unreachable_code_linter <- function(allow_comment_regex = getOption("covr.exclud
 
   drop_valid_comments <- function(expr, valid_comment_re) {
     is_valid_comment <- xml2::xml_name(expr) == "COMMENT" &
-      re_matches(xml_text(expr), valid_comment_re)
+      re_matches_logical(xml_text(expr), valid_comment_re)
     expr[!is_valid_comment]
   }
 

R/utils.R

@@ -195,6 +195,17 @@ release_bullets <- function() {
 platform_independent_order <- function(x) order(tolower(x), method = "radix")
 platform_independent_sort <- function(x) x[platform_independent_order(x)]
 
+#' re_matches with type-stable logical output
+#' TODO(r-lib/rex#94): Use re_matches() option directly & deprecate this.
+#' @noRd
+re_matches_logical <- function(x, regex, ...) {
+  res <- re_matches(x, regex, ...)
+  if (is.data.frame(res)) {
+    res <- complete.cases(res)
+  }
+  res
+}
+
 #' Extract text from `STR_CONST` nodes
 #'
 #' Convert `STR_CONST` `text()` values into R strings. This is useful to account for arbitrary