lt

Count of public functions declared by NAMESPACE export() directives, or R/ top-level definitions matching an exportPattern when only patterns are used.

Number of top-level function definitions in R/ files that are not exported, i.e. helpers kept private to the package.

Total lines across code files in R/, src/, tests/, man/, and vignettes/, with images and other binary files excluded. Rust sources under src/ count and vendored Rust crates do not.

Raw line count of source files under the R/ directory, counting blank and comment lines too.

Raw line count of compiled source and header files under src/, in C, C++, Fortran and Rust, with vendored Rust crates left out.

Raw line count of every file under the tests/ directory, excluding binary and other non-code files.

Number of R function definitions the static analyzer detected across the package's R/ source, counted one per definition.

Number of C++ functions the analyzer detected in the package's compiled sources under src/, one count per function.

Number of C functions the analyzer detected in the package's compiled sources under src/, one count per function.

Number of Fortran subroutines and functions the analyzer detected in the package's compiled sources under src/.

Number of Rust functions the analyzer detected under src/, with vendored crates left out.

Share, from 0 to 1, of all counted lines of code (R, src, tests, docs, vignettes) living in compiled files under src/, Rust included and vendored Rust crates left out.

Total lines of source across all non-binary files in the package's man/ directory, i.e. its Rd help pages.

Share of the package's exported symbols that appear as a name or alias in at least one help page, with lowercase .rd files counted and Rd macro files under man/macros left out.

Share of help pages that include a references section. It counts references written in the help pages and says nothing about a bibliography file.

Share of help pages carrying an examples section, with lowercase .rd files counted and Rd macro files under man/macros left out.

Number of help pages that contain at least one examples section, with lowercase .rd files counted and Rd macro files under man/macros left out.

Average share of a function's usage arguments lacking a matching entry in its arguments section, over exported functions, with lowercase .rd files counted.

Share of exported-function help pages that document their return value with a value section, with lowercase .rd files counted.

One when the analysed release carries a README at the package root, in Markdown, R Markdown, Quarto or plain text.

One when the analysed release carries at least one vignette source under vignettes/, in any engine R builds.

One when the analysed release carries a NEWS file in any location R reads, at the root or under inst/.

One when the analysed release carries an inst/CITATION file. The file is read as text and never run.

Number of help pages in the analysed release, counting lowercase .rd files and leaving out Rd macro files under man/macros.

Number of help pages whose examples run in a plain check, because some example code sits outside dontrun, donttest, dontshow and testonly.

Number of help pages whose examples run only when donttest examples are enabled, which R CMD check does with its as-cran option.

Number of help pages whose example code sits only inside dontrun, dontshow or testonly. Code in dontshow and testonly does run, but it is hidden from the reader, so no example the reader sees is run.

Approximate number of individual test blocks (such as test_that() calls) defined across the files in the package's tests/ directory.

Number of tests the main test framework defines, counted in its own unit, such as test_that() blocks for testthat or test functions for RUnit.

Total lines of code in the tests/ directory divided by the lines of code in R/, left blank when R/ has no lines.

Count of expect_snapshot() and expect_snapshot_file() calls in test R files, plus the number of stored snapshot files under tests/testthat/_snaps/.

Flag set to one when any file at all exists under the package's tests/ directory, and zero otherwise.

Share of NAMESPACE-exported functions whose name appears as a literal word token somewhere in the tests/ files, and left blank when nothing is exported.

Average cyclomatic complexity of the package's R functions, where each function scores one plus its number of branching decision points.

Highest cyclomatic complexity among the package's R functions, flagging its single most branch-heavy and hardest-to-test routine.

Median cyclomatic complexity across the package's R functions, the typical function's branch count, resistant to a few very complex outliers.

Average length in lines of a function's body across the package, a rough gauge of how large typical functions are.

Number of R functions defined in the package, each treated as one node in its syntactic call graph.

Count of distinct directed caller-to-callee links where one package function calls another package function, excluding self-calls and duplicates.

Highest number of call connections (functions it calls plus functions that call it) attached to any single function.

Average call connections per function across all nodes, counting both calls made and calls received, including unconnected functions.

Count of package functions that neither call nor are called by any other package function (degree zero).

Number of connected components formed by functions linked through calls, where functions with no call edges are not counted.

Total number of .Call, .C, .Fortran, and .External invocations in R code that reach into compiled C/C++/Fortran routines.

Number of S3 methods the package registers, counted from the S3method(generic, class) directives declared in its NAMESPACE file.

Count of formal S4 class definitions in the package's R source, identified by setClass() calls from the methods system.

Count of S4 generic functions the package declares in its R code, identified by setGeneric() calls.

Count of S4 methods the package defines for generics on specific classes, identified by setMethod() calls in R source.

Count of R6 class definitions in the package's R source, found by calls to the R6Class constructor from the R6 package.

Count of classes built with the newer S7 object system, identified by new_class() calls in the package's R source.

Count of Reference Classes (R5) defined in the package's R source, identified by setRefClass() calls from the methods system.

A weighted tally of risky constructs in R/ code such as eval(parse()), system(paste()), non-literal Sys.setenv, and network calls inside load hooks.

Number of likely credential leaks across non-binary text files such as AWS keys, GitHub tokens, and api-key/secret/password assignments to long literal strings.

Per 1000 lines of R code, count of global-state writes such as <<-, assign() to the global environment, options() setters, and Sys.setenv().

Per 1000 lines of R code, how often dated idioms appear, such as bare T and F, risky 1-to-n index ranges, in-function require() or library() calls, and .Internal() calls.

How often R/ code reaches into another package's private, unexported internals.

Number of packages the DESCRIPTION lists under Imports plus Depends, with version constraints stripped off and base R itself excluded.

Cross-version measure, derived from the ordered release series, of how much the direct dependency set shifts as packages are added or dropped between releases.

1 when every token in the License field matches a known R-canonical or SPDX identifier from a fixed allowlist.

1 when every license token is OSI-approved, excluding CC0, CC-BY, Unlimited, and bare file-reference licenses that cannot be verified.

When the license cites a LICENSE file, one if the file is present and, for MIT and BSD templates, its YEAR and COPYRIGHT HOLDER lines are filled. A full license text also counts as complete.