restructure script

Author: Mukulyadav2004

.ci/check-options.R

@@ -0,0 +1,68 @@
+# Ensure that data.table options in code match documentation
+check_options_documentation = function(rd_file) {
+  if (!grepl("data.table-options", rd_file)) return(invisible())
+  
+  # Find options in R code
+  get_options_from_code = function() {
+    found = character(0)
+    
+    walk_ast = function(expr) {
+      result = character(0)
+      if (is.call(expr) && length(expr) >= 2 && identical(expr[[1]], quote(getOption)) && is.character(expr[[2]]) && startsWith(expr[[2]], "datatable.")) {
+        result = expr[[2]]
+      }
+      if (is.recursive(expr)) {
+        result = c(result, unlist(lapply(expr, walk_ast)))
+      }
+      result
+    }
+    r_files = list.files("R", pattern = "\\.R$", full.names = TRUE)
+    for (file in r_files) {
+      tryCatch({
+        found = c(found, unlist(lapply(parse(file = file), walk_ast)))
+      }, error = function(e) {})
+    }
+    sort(unique(found))
+  }
+  
+  # Find options in documentation
+  get_options_from_doc = function(rd_file) {
+    if (!file.exists(rd_file)) return(character(0))
+    
+    tryCatch({
+      found = character(0)
+      walk_rd = function(rd_element) {
+        result = character(0)
+        if (is.list(rd_element)) {
+          if (!is.null(attr(rd_element, "Rd_tag")) && attr(rd_element, "Rd_tag") == "\\code" && length(rd_element) >= 1) {
+            content = rd_element[[1]]
+            if (is.character(content) && startsWith(content, "datatable.")) {
+              result = content
+            }
+          }
+          result = c(result, unlist(lapply(rd_element, walk_rd)))
+        }
+        result
+      }
+      found = walk_rd(tools::parse_Rd(rd_file))
+      sort(unique(found))
+    }, error = function(e) character(0))
+  }
+
+  code_opts = get_options_from_code()
+  doc_opts = get_options_from_doc(rd_file)
+  code_opts = setdiff(code_opts, "datatable.alloc")
+
+  miss_in_doc = setdiff(code_opts, doc_opts)
+  miss_in_code = setdiff(doc_opts, code_opts)
+
+  if (length(miss_in_doc) > 0 || length(miss_in_code) > 0) {
+    if (length(miss_in_doc) > 0) {
+      cat("Options in code but missing from docs:", paste(miss_in_doc, collapse = ", "), "\n")
+    }
+    if (length(miss_in_code) > 0) {
+      cat("Options in docs but not in code:", paste(miss_in_code, collapse = ", "), "\n")
+    }
+    stop("Please sync man/data.table-options.Rd with code options")
+  }
+}

.ci/linters/rd/options_doc_check.R

@@ -62,3 +62,11 @@ jobs:
       - name: Lint
         run: for (f in list.files('.ci/linters/md', full.names=TRUE)) source(f)
         shell: Rscript {0}
+  lint-rd:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: r-lib/actions/setup-r@v2
+      - name: Lint Rd files
+        run: Rscript .ci/lint.R .ci/linters/rd man '[.]Rd$'
+        

.github/workflows/code-quality.yaml

@@ -7,22 +7,18 @@
 \description{
   The data.table package uses a number of global options to control its
   behavior. These are regular R options that can be set with options()
-  and retrieved with getOption().
+  and retrieved with getOption(). For example:
+  \preformatted{
+    # Get the current value of an option
+    getOption("datatable.print.topn")
 
+    # Set a new value for an option
+    options(datatable.print.topn = 10)
+  }
   This page provides a comprehensive, up-to-date list of all user-configurable
   options.
 }
 
-\usage{
-\preformatted{
-# Get the current value of an option
-getOption("datatable.print.topn")
-
-# Set a new value for an option
-options(datatable.print.topn = 10)
-}
-}
-
 \section{Printing Options}{
   \describe{
     \item{\code{datatable.print.topn}}{An integer. When a data.table is printed,
@@ -132,16 +128,6 @@ options(datatable.print.topn = 10)
     \item{\code{datatable.verbose}}{A logical. If \code{TRUE}, `data.table` will
       print detailed diagnostic information as it processes a query.
       Default: \code{FALSE}.}
-    \item{\code{datatable.pedantic}}{A logical. If \code{TRUE}, `data.table`
-      enters a "pedantic" mode, issuing helpful warnings for potentially
-      unintentional user behavior.
-      Default: \code{FALSE}.}
-    \item{\code{datatable.dfdispatchwarn}}{A logical. If \code{TRUE}, warns
-      when a generic function from another package is applied to a `data.table`.
-      Default: \code{TRUE}.}
-    \item{\code{datatable.warnredundantby}}{A logical. If \code{TRUE}, `data.table`
-      will warn when grouping by columns that are already the key of the table.
-      Default: \code{TRUE}.}
     \item{\code{datatable.enlist}}{Experimental feature. If set to a function
       (e.g., `list`), the `j` expression can return a `list`, which will then
       be "enlisted" into columns in the result.