more namespace importing

NAMESPACE

@@ -158,4 +158,10 @@ importFrom(utils,head)
 importFrom(utils,relist)
 importFrom(utils,tail)
 importFrom(xml2,as_list)
+importFrom(xml2,xml_attr)
+importFrom(xml2,xml_attrs)
 importFrom(xml2,xml_find_all)
+importFrom(xml2,xml_find_chr)
+importFrom(xml2,xml_find_first)
+importFrom(xml2,xml_find_num)
+importFrom(xml2,xml_text)

R/T_and_F_symbol_linter.R

@@ -62,11 +62,11 @@ T_and_F_symbol_linter <- function() { # nolint: object_name.
       return(list())
     }
 
-    bad_exprs <- xml2::xml_find_all(source_expression$xml_parsed_content, xpath)
-    bad_assigns <- xml2::xml_find_all(source_expression$xml_parsed_content, xpath_assignment)
+    bad_exprs <- xml_find_all(source_expression$xml_parsed_content, xpath)
+    bad_assigns <- xml_find_all(source_expression$xml_parsed_content, xpath_assignment)
 
     make_lints <- function(expr, fmt) {
-      symbol <- xml2::xml_text(expr)
+      symbol <- xml_text(expr)
       lint_message <- sprintf(fmt, replacement_map[symbol], symbol)
       xml_nodes_to_lints(
         xml = expr,

R/any_duplicated_linter.R

@@ -92,17 +92,17 @@ any_duplicated_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    any_duplicated_expr <- xml2::xml_find_all(xml, any_duplicated_xpath)
+    any_duplicated_expr <- xml_find_all(xml, any_duplicated_xpath)
     any_duplicated_lints <- xml_nodes_to_lints(
       any_duplicated_expr,
       source_expression = source_expression,
       lint_message = "anyDuplicated(x, ...) > 0 is better than any(duplicated(x), ...).",
       type = "warning"
     )
 
-    length_unique_expr <- xml2::xml_find_all(xml, length_unique_xpath)
+    length_unique_expr <- xml_find_all(xml, length_unique_xpath)
     lint_message <- ifelse(
-      is.na(xml2::xml_find_first(length_unique_expr, uses_nrow_xpath)),
+      is.na(xml_find_first(length_unique_expr, uses_nrow_xpath)),
       "anyDuplicated(x) == 0L is better than length(unique(x)) == length(x).",
       "anyDuplicated(DF$col) == 0L is better than length(unique(DF$col)) == nrow(DF)"
     )

R/any_is_na_linter.R

@@ -53,7 +53,7 @@ any_is_na_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     xml_nodes_to_lints(
       bad_expr,

R/assignment_linter.R

@@ -106,21 +106,21 @@ assignment_linter <- function(allow_cascading_assign = TRUE,
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     if (length(bad_expr) == 0L) {
       return(list())
     }
 
-    operator <- xml2::xml_text(bad_expr)
+    operator <- xml_text(bad_expr)
     lint_message_fmt <- rep("Use <-, not %s, for assignment.", length(operator))
     lint_message_fmt[operator %in% c("<<-", "->>")] <-
       "%s can have hard-to-predict behavior; prefer assigning to a specific environment instead (with assign() or <-)."
     lint_message_fmt[operator == "%<>%"] <-
       "Avoid the assignment pipe %s; prefer using <- and %%>%% separately."
 
     if (!allow_trailing) {
-      bad_trailing_expr <- xml2::xml_find_all(xml, trailing_assign_xpath)
-      trailing_assignments <- xml2::xml_attrs(bad_expr) %in% xml2::xml_attrs(bad_trailing_expr)
+      bad_trailing_expr <- xml_find_all(xml, trailing_assign_xpath)
+      trailing_assignments <- xml_attrs(bad_expr) %in% xml_attrs(bad_trailing_expr)
       lint_message_fmt[trailing_assignments] <- "Assignment %s should not be trailing at the end of a line."
     }
 

R/backport_linter.R

@@ -50,8 +50,8 @@ backport_linter <- function(r_version = getRversion(), except = character()) {
 
     xml <- source_expression$xml_parsed_content
 
-    all_names_nodes <- xml2::xml_find_all(xml, names_xpath)
-    all_names <- xml2::xml_text(all_names_nodes)
+    all_names_nodes <- xml_find_all(xml, names_xpath)
+    all_names <- xml_text(all_names_nodes)
 
     # not sapply/vapply, which may over-simplify to vector
     # rbind makes sure we have a matrix with dimensions [n_versions x n_names]

R/boolean_arithmetic_linter.R

@@ -62,7 +62,7 @@ boolean_arithmetic_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    any_expr <- xml2::xml_find_all(xml, any_xpath)
+    any_expr <- xml_find_all(xml, any_xpath)
 
     xml_nodes_to_lints(
       any_expr,

R/brace_linter.R

@@ -157,7 +157,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_open_curly),
+        xml_find_all(xml, xp_open_curly),
         source_expression = source_expression,
         lint_message =
           "Opening curly braces should never go on their own line and should always be followed by a new line."
@@ -167,7 +167,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_paren_brace),
+        xml_find_all(xml, xp_paren_brace),
         source_expression = source_expression,
         lint_message = "There should be a space before an opening curly brace."
       )
@@ -176,7 +176,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_closed_curly),
+        xml_find_all(xml, xp_closed_curly),
         source_expression = source_expression,
         lint_message =
           "Closing curly-braces should always be on their own line, unless they are followed by an else."
@@ -186,7 +186,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_else_same_line),
+        xml_find_all(xml, xp_else_same_line),
         source_expression = source_expression,
         lint_message = "`else` should come on the same line as the previous `}`."
       )
@@ -195,7 +195,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_function_brace),
+        xml_find_all(xml, xp_function_brace),
         source_expression = source_expression,
         lint_message = "Any function spanning multiple lines should use curly braces."
       )
@@ -204,7 +204,7 @@ brace_linter <- function(allow_single_line = FALSE) {
     lints <- c(
       lints,
       xml_nodes_to_lints(
-        xml2::xml_find_all(xml, xp_if_else_match_brace),
+        xml_find_all(xml, xp_if_else_match_brace),
         source_expression = source_expression,
         lint_message = "Either both or neither branch in `if`/`else` should use curly braces."
       )

R/class_equals_linter.R

@@ -51,9 +51,9 @@ class_equals_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
-    operator <- xml_find_char(bad_expr, "string(*[2])")
+    operator <- xml_find_chr(bad_expr, "string(*[2])")
     lint_message <- sprintf(
       "Instead of comparing class(x) with %s, use inherits(x, 'class-name') or is.<class> or is(x, 'class')",
       operator

R/commas_linter.R

@@ -67,15 +67,15 @@ commas_linter <- function() {
     xml <- source_expression$xml_parsed_content
 
     before_lints <- xml_nodes_to_lints(
-      xml2::xml_find_all(xml, xpath_before),
+      xml_find_all(xml, xpath_before),
       source_expression = source_expression,
       lint_message = "Commas should never have a space before.",
       range_start_xpath = "number(./preceding-sibling::*[1]/@col2 + 1)", # start after preceding expression
       range_end_xpath = "number(./@col1 - 1)" # end before comma
     )
 
     after_lints <- xml_nodes_to_lints(
-      xml2::xml_find_all(xml, xpath_after),
+      xml_find_all(xml, xpath_after),
       source_expression = source_expression,
       lint_message = "Commas should always have a space after.",
       range_start_xpath = "number(./@col2 + 1)", # start and end after comma

R/comment_linters.R

@@ -79,8 +79,8 @@ commented_code_linter <- function() {
     if (!is_lint_level(source_expression, "file")) {
       return(list())
     }
-    all_comment_nodes <- xml2::xml_find_all(source_expression$full_xml_parsed_content, "//COMMENT")
-    all_comments <- xml2::xml_text(all_comment_nodes)
+    all_comment_nodes <- xml_find_all(source_expression$full_xml_parsed_content, "//COMMENT")
+    all_comments <- xml_text(all_comment_nodes)
     code_candidates <- re_matches(all_comments, code_candidate_regex, global = FALSE, locations = TRUE)
     extracted_code <- code_candidates[, "code"]
     # ignore trailing ',' when testing for parsability

R/condition_message_linter.R

@@ -59,7 +59,7 @@ condition_message_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     sep_value <- get_r_string(bad_expr, xpath = "./expr/SYMBOL_SUB[text() = 'sep']/following-sibling::expr/STR_CONST")
 
     bad_expr <- bad_expr[is.na(sep_value) | sep_value %in% c("", " ")]

R/conjunct_test_linter.R

@@ -72,14 +72,14 @@ conjunct_test_linter <- function(allow_named_stopifnot = TRUE) {
 
     xml <- source_expression$full_xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     if (length(bad_expr) == 0L) {
       return(list())
     }
 
     matched_fun <- xp_call_name(bad_expr)
-    operator <- xml_find_char(bad_expr, "string(expr/*[self::AND2 or self::OR2])")
+    operator <- xml_find_chr(bad_expr, "string(expr/*[self::AND2 or self::OR2])")
     replacement_fmt <- ifelse(
       matched_fun %in% c("expect_true", "expect_false"),
       "write multiple expectations like %1$s(A) and %1$s(B)",

R/consecutive_assertion_linter.R

@@ -55,7 +55,7 @@ consecutive_assertion_linter <- function() {
 
     xml <- source_expression$full_xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     matched_function <- xp_call_name(bad_expr)
     xml_nodes_to_lints(

R/declared_functions.R

@@ -15,5 +15,5 @@ declared_s3_generics <- function(x) {
     "/expr/SYMBOL/text()"
   )
 
-  as.character(xml2::xml_find_all(x, xpath))
+  as.character(xml_find_all(x, xpath))
 }

R/duplicate_argument_linter.R

@@ -47,14 +47,14 @@ duplicate_argument_linter <- function(except = c("mutate", "transmute")) {
 
     xml <- source_expression$full_xml_parsed_content
 
-    calls <- xml2::xml_find_all(xml, xpath_call_with_args)
+    calls <- xml_find_all(xml, xpath_call_with_args)
 
     if (length(except) > 0L) {
       calls_text <- get_r_string(xp_call_name(calls))
       calls <- calls[!(calls_text %in% except)]
     }
 
-    all_arg_nodes <- lapply(calls, xml2::xml_find_all, xpath_arg_name)
+    all_arg_nodes <- lapply(calls, xml_find_all, xpath_arg_name)
     arg_names <- lapply(all_arg_nodes, get_r_string)
     is_duplicated <- lapply(arg_names, duplicated)
 

R/empty_assignment_linter.R

@@ -49,7 +49,7 @@ empty_assignment_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     xml_nodes_to_lints(
       bad_expr,

R/equals_na_linter.R

@@ -45,7 +45,7 @@ equals_na_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     xml_nodes_to_lints(
       bad_expr,

R/expect_comparison_linter.R

@@ -70,9 +70,9 @@ expect_comparison_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
-    comparator <- xml_find_char(bad_expr, "string(expr[2]/*[2])")
+    comparator <- xml_find_chr(bad_expr, "string(expr[2]/*[2])")
     expectation <- comparator_expectation_map[comparator]
     lint_message <- sprintf("%s(x, y) is better than expect_true(x %s y).", expectation, comparator)
     xml_nodes_to_lints(bad_expr, source_expression, lint_message = lint_message, type = "warning")

R/expect_identical_linter.R

@@ -88,7 +88,7 @@ expect_identical_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     xml_nodes_to_lints(
       bad_expr,
       source_expression = source_expression,

R/expect_length_linter.R

@@ -39,7 +39,7 @@ expect_length_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     matched_function <- xp_call_name(bad_expr)
     lint_message <- sprintf("expect_length(x, n) is better than %s(length(x), n)", matched_function)
     xml_nodes_to_lints(bad_expr, source_expression, lint_message, type = "warning")

R/expect_named_linter.R

@@ -48,7 +48,7 @@ expect_named_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     matched_function <- xp_call_name(bad_expr)
     lint_message <- sprintf("expect_named(x, n) is better than %s(names(x), n)", matched_function)
 

R/expect_not_linter.R

@@ -37,7 +37,7 @@ expect_not_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     xml_nodes_to_lints(
       bad_expr,

R/expect_null_linter.R

@@ -60,7 +60,7 @@ expect_null_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     matched_function <- xp_call_name(bad_expr)
     msg <- ifelse(

R/expect_s3_class_linter.R

@@ -61,7 +61,7 @@ expect_s3_class_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     matched_function <- xp_call_name(bad_expr)
     msg <- ifelse(
       matched_function %in% c("expect_equal", "expect_identical"),

R/expect_s4_class_linter.R

@@ -42,7 +42,7 @@ expect_s4_class_linter <- function() {
     # TODO(michaelchirico): also catch expect_{equal,identical}(methods::is(x), k).
     #   this seems empirically rare, but didn't check many S4-heavy packages.
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     xml_nodes_to_lints(
       bad_expr,
       source_expression = source_expression,

R/expect_true_false_linter.R

@@ -46,11 +46,11 @@ expect_true_false_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
 
     # NB: use expr/$node, not expr[$node], to exclude other things (especially ns:: parts of the call)
     call_name <- xp_call_name(bad_expr, condition = "starts-with(text(), 'expect_')")
-    truth_value <- xml_find_char(bad_expr, "string(expr/NUM_CONST[text() = 'TRUE' or text() = 'FALSE'])")
+    truth_value <- xml_find_chr(bad_expr, "string(expr/NUM_CONST[text() = 'TRUE' or text() = 'FALSE'])")
     lint_message <- sprintf(
       "expect_%s(x) is better than %s(x, %s)",
       tolower(truth_value), call_name, truth_value

R/expect_type_linter.R

@@ -52,7 +52,7 @@ expect_type_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    bad_expr <- xml2::xml_find_all(xml, xpath)
+    bad_expr <- xml_find_all(xml, xpath)
     matched_function <- xp_call_name(bad_expr)
     msg <- ifelse(
       matched_function %in% c("expect_equal", "expect_identical"),

R/extraction_operator_linter.R

@@ -67,8 +67,8 @@ extraction_operator_linter <- function() {
     }
 
     xml <- source_expression$xml_parsed_content
-    bad_exprs <- xml2::xml_find_all(xml, xpath)
-    msgs <- sprintf("Use `[[` instead of `%s` to extract an element.", xml2::xml_text(bad_exprs))
+    bad_exprs <- xml_find_all(xml, xpath)
+    msgs <- sprintf("Use `[[` instead of `%s` to extract an element.", xml_text(bad_exprs))
 
     xml_nodes_to_lints(
       bad_exprs,

R/fixed_regex_linter.R

@@ -114,12 +114,12 @@ fixed_regex_linter <- function() {
 
     xml <- source_expression$xml_parsed_content
 
-    patterns <- xml2::xml_find_all(xml, xpath)
+    patterns <- xml_find_all(xml, xpath)
     pattern_strings <- get_r_string(patterns)
     is_static <- is_not_regex(pattern_strings)
 
     fixed_equivalent <- encodeString(get_fixed_string(pattern_strings[is_static]), quote = '"', justify = "none")
-    call_name <- xml_find_char(patterns[is_static], "string(preceding-sibling::expr[last()]/SYMBOL_FUNCTION_CALL)")
+    call_name <- xml_find_chr(patterns[is_static], "string(preceding-sibling::expr[last()]/SYMBOL_FUNCTION_CALL)")
 
     is_stringr <- startsWith(call_name, "str_")
     replacement <- ifelse(