Support excluding entire directories

.lintr

@@ -1,2 +1,8 @@
 linters: with_defaults(line_length_linter(120))
-exclusions: list("inst/doc/creating_linters.R" = 1, "inst/example/bad.R", "tests/testthat/exclusions-test")
+exclusions: list(
+  "inst/doc/creating_linters.R" = 1,
+  "inst/example/bad.R",
+  "tests/testthat/dummy_packages",
+  "tests/testthat/exclusions-test",
+  "tests/testthat/knitr_malformed/incomplete_r_block.Rmd"
+ )

DESCRIPTION

@@ -30,7 +30,8 @@ Imports:
     xmlparsedata (>= 1.0.3)
 Suggests:
     rmarkdown,
-    mockery
+    mockery,
+    withr
 License: MIT + file LICENSE
 LazyData: true
 Encoding: UTF-8

NEWS.md

@@ -13,6 +13,8 @@
 * Fix handling zero-length variable name error (#566, #567, @renkun-ken)
 * New `missing_argument_linter()` (#563, #565, @renkun-ken)
 * New `sprintf_linter()` (#544, #578, @renkun-ken)
+* exclusions are now always relative to the location of the `.lintr` file and they support excluding entire directories
+  by specifying a directory instead of a file (#158, #438, @AshesITR)
 
 # lintr 2.0.1
 

R/cache.R

@@ -7,9 +7,10 @@
 #' @return 0 for success, 1 for failure, invisibly.
 #' @export
 clear_cache <- function(file = NULL, path = NULL) {
-  read_settings(file)
-
   if (is.null(path)) {
+    # Only retrieve settings if `path` isn't specified.
+    # Otherwise, other settings may inadvertently be loaded, such as exclusions.
+    read_settings(file)
     path <- settings$cache_directory
   }
 
@@ -27,9 +28,10 @@ get_cache_file_path <- function(file, path) {
 }
 
 load_cache <- function(file, path = NULL) {
-  read_settings(file)
-
   if (is.null(path)) {
+    # Only retrieve settings if `path` isn't specified.
+    # Otherwise, other settings may inadvertently be loaded, such as exclusions.
+    read_settings(file)
     path <- settings$cache_directory
   }
 
@@ -44,9 +46,10 @@ load_cache <- function(file, path = NULL) {
 }
 
 save_cache <- function(cache, file, path = NULL) {
-  read_settings(file)
-
   if (is.null(path)) {
+    # Only retrieve settings if `path` isn't specified.
+    # Otherwise, other settings may inadvertently be loaded, such as exclusions.
+    read_settings(file)
     path <- settings$cache_directory
   }
 

R/exclude.R

@@ -9,7 +9,8 @@
 #' \item{single line in the source file. default: \code{# nolint}}
 #' \item{line range in the source file. default: \code{# nolint start}, \code{# nolint end}}
 #' \item{exclusions parameter, a named list of the files and lines to exclude, or just the filenames
-#' if you want to exclude the entire file.}
+#' if you want to exclude the entire file, or the directory names if you want to exclude all files
+#' in a directory.}
 #' }
 exclude <- function(lints, exclusions = settings$exclusions, ...) {
   if (length(lints) <= 0) {
@@ -71,7 +72,26 @@ parse_exclusions <- function(file, exclude = settings$exclude,
   sort(unique(c(exclusions, which(rex::re_matches(lines, exclude)))))
 }
 
-normalize_exclusions <- function(x, normalize_path=TRUE) {
+#' Normalize lint exclusions
+#'
+#' @param x Exclusion specification
+#'  - A character vector of filenames or directories relative to \code{root}
+#'  - A named list of integers specifying lines to be excluded per file
+#' @param normalize_path Should the names of the returned exclusion list be normalized paths?
+#' If no, they will be relative to \code{root}.
+#' @param root Base directory for relative filename resolution.
+#' @param pattern If non-NULL, only exclude files in excluded directories if they match
+#' \code{pattern}. Passed to \link[base]{list.files} if a directory is excluded.
+#'
+#' @value A named list of line numbers to exclude, or the sentinel \code{Inf} for completely
+#' excluded files. The names of the list specify the filenames to be excluded.
+#' If \code{normalize_path} is \code{TRUE}, they will be normalized relative to \code{root}.
+#' Otherwise the paths are left as provided (relative to \code{root} or absolute).
+#'
+#' @keywords internal
+normalize_exclusions <- function(x, normalize_path = TRUE,
+                                 root = getwd(),
+                                 pattern = NULL) {
   if (is.null(x) || length(x) <= 0) {
     return(list())
   }
@@ -101,8 +121,42 @@ normalize_exclusions <- function(x, normalize_path=TRUE) {
     }
   }
 
+  paths <- names(x)
+  rel_path <- !is_absolute_path(paths)
+  paths[rel_path] <- file.path(root, paths[rel_path])
+
+  is_dir <- dir.exists(paths)
+  if (any(is_dir)) {
+    dirs <- names(x)[is_dir]
+    x <- x[!is_dir]
+    all_file_names <- unlist(lapply(
+      dirs,
+      function(dir) {
+        dir_path <- if (is_absolute_path(dir)) dir else file.path(root, dir)
+        files <- list.files(
+          path = dir_path,
+          pattern = pattern,
+          recursive = TRUE
+        )
+        file.path(dir, files) # non-normalized relative paths
+      }
+    ))
+
+    # Only exclude file if there is no more specific exclusion already
+    all_file_names <- setdiff(all_file_names, names(x))
+
+    dir_exclusions <- as.list(rep_len(Inf, length(all_file_names)))
+    names(dir_exclusions) <- all_file_names
+    x <- c(x, dir_exclusions)
+  }
+
   if (normalize_path) {
-    x <- x[file.exists(names(x))]       # remove exclusions for non-existing files
+    paths <- names(x)
+    # specify relative paths w.r.t. root
+    rel_path <- !is_absolute_path(paths)
+    paths[rel_path] <- file.path(root, paths[rel_path])
+    names(x) <- paths
+    x <- x[file.exists(paths)]       # remove exclusions for non-existing files
     names(x) <- normalizePath(names(x)) # get full path for remaining files
   }
 

R/expect_lint.R

@@ -19,6 +19,9 @@
 #' is not recommended for new code.
 #' @param ... arguments passed to \code{\link{lint}}, e.g. the linters or cache to use.
 #' @param file if not \code{NULL}, read content from the specified file rather than from \code{content}.
+#' @param language temporarily override Rs \code{LANGUAGE} envvar, controlling localisation of base
+#' R error messages. This makes testing them reproducible on all systems irrespective of their
+#' native R language setting.
 #' @return \code{NULL}, invisibly.
 #' @examples
 #' # no expected lint
@@ -35,7 +38,11 @@
 #'   list(list(message="superfluous", line_number=2), list(message="superfluous", line_number=3)),
 #'   trailing_blank_lines_linter)
 #' @export
-expect_lint <- function(content, checks, ..., file = NULL) {
+expect_lint <- function(content, checks, ..., file = NULL, language = "en") {
+  oldlang <- Sys.getenv("LANGUAGE")
+  Sys.setenv(LANGUAGE = language)
+  on.exit(Sys.setenv(LANGUAGE = oldlang))
+
   if (is.null(file)) {
     file <- tempfile()
     on.exit(unlink(file))

R/lint.R

@@ -149,7 +149,7 @@ reorder_lints <- function(lints) {
 #'   lint_dir(
 #'     linters = list(semicolon_terminator_linter())
 #'     cache = TRUE,
-#'     exclusions = list("inst/doc/creating_linters.R" = 1, "inst/example/bad.R")
+#'     exclusions = list("inst/doc/creating_linters.R" = 1, "inst/example/bad.R", "renv")
 #'   )
 #' }
 #' @export
@@ -164,13 +164,23 @@ lint_dir <- function(path = ".", relative_path = TRUE, ..., exclusions = NULL,
   if (isTRUE(parse_settings)) {
     read_settings(path)
     on.exit(clear_settings, add = TRUE)
+
+    exclusions <- c(exclusions, settings$exclusions)
   }
 
-  files <- dir(path,
+  exclusions <- normalize_exclusions(
+    exclusions,
+    root = path,
+    pattern = pattern
+  )
+
+  # normalizePath ensures names(exclusions) and files have the same names for the same files.
+  # Otherwise on windows, files might incorrectly not be excluded in to_exclude
+  files <- normalizePath(dir(path,
     pattern = pattern,
     recursive = TRUE,
     full.names = TRUE
-  )
+  ))
 
   # Remove fully ignored files to avoid reading & parsing
   to_exclude <- vapply(
@@ -231,17 +241,23 @@ lint_dir <- function(path = ".", relative_path = TRUE, ..., exclusions = NULL,
 #'   lint_package(
 #'     linters = with_defaults(semicolon_linter = semicolon_terminator_linter())
 #'     cache = TRUE,
-#'     exclusions = list("inst/doc/creating_linters.R" = 1, "inst/example/bad.R")
+#'     exclusions = list("inst/doc/creating_linters.R" = 1, "inst/example/bad.R", "data")
 #'   )
 #' }
 #' @export
-lint_package <- function(path = ".", relative_path = TRUE, ..., exclusions = list("R/RcppExports.R")) {
+lint_package <- function(path = ".", relative_path = TRUE, ..., exclusions = list("R/RcppExports.R"), parse_settings = TRUE) {
   path <- find_package(path)
 
-  read_settings(path)
-  on.exit(clear_settings, add = TRUE)
+  if (parse_settings) {
+    read_settings(path)
+    on.exit(clear_settings, add = TRUE)
+  }
 
-  exclusions <- normalize_exclusions(c(exclusions, settings$exclusions), FALSE)
+  exclusions <- normalize_exclusions(
+    c(exclusions, settings$exclusions),
+    root = path,
+    pattern = pattern
+  )
 
   lints <- lint_dir(file.path(path, c("R", "tests", "inst", "vignettes", "data-raw")),
                     relative_path = FALSE, exclusions = exclusions, parse_settings = FALSE, ...)

R/settings.R

@@ -34,7 +34,12 @@ read_settings <- function(filename) {
   for (setting in names(default_settings)) {
     value <- get_setting(setting, config, default_settings)
     if (setting == "exclusions") {
-      value <- normalize_exclusions(value)
+      if (!is.null(config_file)) {
+        root <- dirname(config_file)
+      } else {
+        root <- getwd()
+      }
+      value <- normalize_exclusions(value, root = root)
     }
 
     settings[[setting]] <- value

tests/testthat/dummy_packages/assignmentLinter/DESCRIPTION

@@ -0,0 +1,9 @@
+Package: assignmentLinter
+Type: Package
+Title: What the package does (short line)
+Version: 1.0
+Date: 2019-12-17
+Author: Who wrote it
+Maintainer: Who to complain to <[email protected]>
+Description: More about what it does (maybe more than one line)
+License: What license is it under?

tests/testthat/dummy_packages/assignmentLinter/NAMESPACE

@@ -0,0 +1 @@
+exportPattern("^[[:alpha:]]+")

tests/testthat/dummy_packages/assignmentLinter/R/abc.R

@@ -0,0 +1,2 @@
+abc = 123
+ghi <- 456

tests/testthat/dummy_packages/assignmentLinter/R/jkl.R

@@ -0,0 +1,2 @@
+jkl = 456
+mno = 789