/awesome-r-pkgtools

A curated list of awesome tools for R package development

Primary LanguageHTMLMIT LicenseMIT

Awesome R package development Awesome Track Awesome List

A curated list of awesome tools to assist R 📦 development.

Note before:

  • Not all tools are available on CRAN; some might be available only via GitHub or GitLab.
  • Only tools helpful for package development are included, and not other resources (like books, talks, presentations, etc.).
  • Tools which are part of publicly archived/retired GitHub repositories are not included.

Contributing

If you wish to suggest any additional tools, please make a PR request or raise an issue here.

Please note that the awesome-r-pkgtools project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

⚠️⚠️ Note Before ⚠️⚠️

If you are not using the latest release of pandoc, please change only the README.Rmd document.

Swiss army knives 🛠

Tools useful across all stages of package development (some of these are meta-packages and their component packages are also included in respective sections for the sake of completeness).

Package skeletons 💀

Naming things 🧸

  • {available} (to check if a package name is available to use)

  • {collidr} (to check for namespace collisions)

  • {changer} (to change the name of an existing R package)

Working with package components

  • {rprojroot} (accessing files w.r.t. package root directory)

  • {desc} (manipulating DESCRIPTION files)

  • {withr} (to manage package side effects by safely and temporarily modifying global states)

  • {pkgload} (to simulate the process of installing and loading a package)

  • {pkgbuild} (to find tools needed to build packages)

Package configuration

  • {config} (to manage environment specific configuration values)

Package management tools

  • {pkgcache} (to cache ‘CRAN’-like metadata and packages)

Documentation 📚

Manual

  • {roxygen2} (to generate R package documentation from inline R comments)

  • {Rd2roxygen} (in case you inherit a project where documentation was not written using {roxygen2})

  • {sinew} (generate {roxygen2} skeletons)

  • {roclang} (helpers for diffusing content across function documentation)

  • {Rdpack} (for inserting references, figures, and evaluated examples in Rd docs)

  • {roxygen2md} (using Markdown syntax in package documentation)

  • {rd2list} (converts Rd docs to a human-readable list)

  • roxygen2Comment (Rstudio addin for adding and remove {roxygen2} comment)

Math in package manual

  • {katex} (to convert latex math expressions to HTML for use in package manual pages)

  • {mathjaxr} (provides ‘MathJax’ and macros to enable its use within Rd files for rendering equations in the HTML help files)

Vignettes

  • {knitr} (a general-purpose tool for dynamic report generation to be used as a vignette builder for R package vignettes)

  • {rmarkdown} (to convert R Markdown documents to a variety of formats)

  • {prettydoc} (creates lightweight yet pretty vignettes)

  • {learnr} (to turn any R Markdown document into an interactive tutorial)

Website

Translation

  • {potools} (for translating messages and checking the “health” of the messaging corpus)

Lifecycle

  • {lifecycle} (to manage the life cycle of exported functions)

Badges and stickers

  • {badger} (query information and generate badges for using in README and GitHub Pages)

  • {hexSticker} (helper functions for creating reproducible hexagon sticker purely in R)

  • hexwall (to create a wall of hexstickers)

Presentation

  • {xaringan} (an R Markdown output format for remark.js slides)

Book

  • {bookdown} (authoring framework for books and technical documents with R Markdown)

Change log and versioning

  • {fledge} (streamlines the process of updating change logs and versioning R packages developed in git repositories)

  • {newsmd} (utilities to add updates to the NEWS.md file)

Documentation quality ✒️

Unit testing 🧪

General

  • {testthat} (a testing framework for R that is easy to learn and use; also provides snapshot testing)

  • {tinytest} (zero-dependency unit testing framework that installs tests with the package)

  • {RUnit} (a standard Unit Testing framework, with additional code inspection and report generation tools)

  • {testit} (a simple package for testing R packages)

  • {roxytest} (inline {testthat} tests with {roxygen2})

  • {exampletestr} (tests based on package examples)

  • {unitizer} (simplifies regression tests by comparing objects produced by test code with earlier versions of those same objects)

  • {r-hedgehog} (property based testing)

  • {autotest} (automatic mutation testing of R packages)

Shiny applications

Web applications

Visual regression testing

Mock testing

  • {mockthat} (function mocking for unit testing to third-party packages)

  • {mockr} (allows mocking functions in the package under test)

  • {testdown} (turn {testthat} results into a {bookdown} project)

Helpers for testing frameworks

  • {testthis} (RStudio addins for working with files that contain tests)

  • {xpectr} (builds unit tests with the {testthat} package by providing tools for generating expectations)

Code analysis 🗂⏱

General

  • {codetools} (code analysis tools for R)

  • {goodpractice} (Swiss army knife for good practices)

  • {inteRgrate} (provides an opinionated set of rules for R package development)

  • {pkgcheck} (checks if package follows good practices recommended for packages in the rOpenSci ecosystem)

  • {rchk} (provides several bug-finding tools that look for memory protection errors in C source code using R API)

  • {sourcetools} (tools for reading, tokenizing, and parsing R code)

Code coverage

  • {covr} (computes code coverage)

  • {covrpage} (provides summary README of code coverage and corresponding tests)

Lint detection

  • {lintr} (static code analysis)

  • {roger} (provides tools for grading the coding style and documentation of R scripts)

  • {cleanr} (tests code for some of the most common code layout flaws)

Code complexity

Code similarity

  • {dupree} (identifies code blocks that have a high level of similarity within a set of R files)

  • {rscc} (provides source code similarity evaluation by variable/function names)

  • {SimilaR} (quantifies the similarity of the code-base of R functions by means of program dependence graphs)

Lines of code

  • {cloc} (counts blank lines, comment lines, and physical lines of source code in source files)

Code performance ⏱️

Benchmarking

  • {bench} (provides high precision benchmarks for R expressions)

  • {microbenchmark} (provides infrastructure to accurately measure and compare the execution time of R expressions)

  • {touchstone} (benchmarking pull requests)

Profiling

  • {profvis} (to profile and visualize profiling data)

  • {proffer} (to create friendlier, faster visualizations for profiling data)

  • {jointprof} (to profile packages with native code in C, C++, Fortran, etc.)

Formatting 🧽

  • {styler} (to format code according to a style guide)

  • {stylermd} (to format text in Markdown documents)

  • {formatR} (to format R source code)

  • AlignAssign (RStudio addin that aligns the assignment operators within a highlighted area)

Dependencies ⚖️

  • {pkgdepends} (to find recursive dependencies of from various sources)

  • {deepdep} (to visualize and explore package dependencies)

  • {itdepends} (to assess usage, measure weights, visualize proportions, and assist removal of dependencies)

  • {DependenciesGraphs} (to visualize package dependencies)

  • {pkgnet} (to build a graph representation of a package and its dependencies)

  • {functiondepends} (to find functions in an unstructured directory and explore their dependencies)

  • {pkgndep} (checks the heaviness of the packages used)

  • {oysteR} (to secure package against insecure dependencies)

  • {attachment} (to deal with package dependencies during package development)

CRAN checks, submission, and status 📬

  • {rcmdcheck} (to run R CMD check form R programmatically)

  • {rhub} (to run R CMD check on CRAN architectures)

  • {checkhelper} (to help avoid problems with CRAN submissions)

  • {foghorn} (to check for results and submission portal status)

  • {urlchecker} (to checks for URL rot)

Usage 🙈

CI/CD 📟

CI/CD: continuous integration and either continuous delivery or continuous deployment

Security/Privacy 👮

  • {digest} (for the creation of hash digests of arbitrary R objects)

  • {hash} (implements a data structure similar to hashes in Perl and dictionaries in Python but with a purposefully R flavor)

  • {gpg} (GNU privacy guard for R)

Build systems

  • {fakemake} (to mock Unix Make build system in case it is unavailable)

Validation frameworks

  • {valtools} (in clinical research and drug development)

Debugging 🔭

  • {debugme} (provides helpers to specify debug messages as special string constants, and control debugging of packages via environment variables)

  • {debugr} (tools to print out the value of R objects/expressions while running an R script)

  • {winch} (provides stack traces for call chains that cross between R and C/C++ function calls)

  • {flow} (to visualize as flow diagrams the logic of functions, expressions, or scripts, which can ease debugging)

Input validation 🔬

  • {checkmate} (fast and versatile argument checks)

  • {assertthat} (to declare the pre and post conditions that you code should satisfy and to produce friendly error messages)

  • {assertive} (provides readable check functions to ensure code integrity)

  • {pkgcond} (better error messages for package users)

  • {dreamerr} (a simple and intuitive, yet powerful and flexible, way to check the arguments passed to a function and to offer informative error messages)

Package metadata 🖨

  • {codemetar} (provides utilities to generate, parse, and modify codemeta.jsonld files automatically for R packages)

  • {codemeta} (a leaner version of {codemetar})

  • {cffr} (provides utilities to generate, parse, modify and validate CITATION.cff files automatically for R packages)

  • {pkgapi} (to create the map of function calls in a package)

  • {packagemetrics} (for comparing among packages)

  • {devtoolbox} (to create a summary report for R package and to extract dependency statistics in a tidy data frame)

  • {pkgattrs} (useful for getting information on the contents of any R package)

  • {foreman} (for unpacking, interrogating and subsetting R packages)

  • {sessioninfo} (to include R session information)

Reverse dependency checks 📡⚰️

  • {revdepcheck} (for automated, isolated, reverse dependency checking)

  • {xfun} (specifically, xfun::rev_check())

Gratitude 🙏💌

To thank the contributors or maintainers of packages you rely on.

Docker container 🛍

  • {containerit} (to package R script/session/workspace and all dependencies as a Docker container by generating a suitable Dockerfile)

  • {usethat} (to automate analytic project setup tasks)

Integration with other languages 🔗

C++

Python

Rust

.NET Framework

JavaScript/HTML/CSS

Julia

Upkeep 🧹

  • {TODOr} (RStudio addin to list things that you need to do or change)

Sundry 🗒

Code of Conduct

Please note that the awesome-r-pkgtools project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.