Packages

Luckily you can grab info for all current CRAN packages with the very handy CRAN_package_db() function.²

cran_pkgs <- as_tibble(tools::CRAN_package_db())

This returns a dataframe containing 18338 rows, where each one is a package, along with 66 variables. We get information like the stuff that’s found in package DESCRIPTION files, but it doesn’t tell us whether a package has a zzz.R file.

One way to do this is to visit the GitHub repo associated with the package, if it has one, and see if a zzz.R exists. Of course, many packages are not on GitHub, but we’re going to ignore those for simplicity.

Github repos

A quick way of discovering if a package has a GitHub repo is to check for ‘github.com’ in the BugReports section of it DESCRIPTION file.³ Again, this doesn’t capture all the possible repos, but is fine for now.

has_repo <- cran_pkgs %>% 
  select(Package, BugReports) %>% 
  filter(str_detect(BugReports, "github")) %>% 
  transmute(
    Package,
    owner_repo = str_extract(
      str_replace_all(paste0(BugReports, "/x"), "//", "/"),
      "(?<=github.com/).*(?=/[a-zA-Z])"
    )
  ) %>% 
  separate(owner_repo, c("owner", "repo"), "/") %>% 
  filter(!is.na(Package), !is.na(owner), !is.na(repo)) %>% 
  distinct(Package, owner, repo) %>% 
  arrange(Package) 

sample_n(has_repo, 5)

## # A tibble: 5 × 3
##   Package       owner      repo          
##   <chr>         <chr>      <chr>         
## 1 PowerTOST     Detlew     PowerTOST     
## 2 pdfetch       abielr     pdfetch       
## 3 torchdatasets mlverse    torchdatasets 
## 4 featureflag   szymanskir featureflag   
## 5 wordpredictor pakjiddat  word-predictor

There were 18338 CRAN packages total and now we have 6691 (36%) that appear to have a GitHub repo.

If you’re wondering why we didn’t just use the package name as the repo name, it’s because they sometimes don’t match, e.g. {baseballDBR} is in a repo called ‘moneyball’.

Now we can use the repo details to build a URL to a potential zzz.R URL. This comes in the form https://raw.githubusercontent.com/<owner>/<repo>/<defaultbranch>/R/zzz.R".

Default branch

You’ll notice we don’t yet know the default branch of the package’s GitHub repo. Historically, we could probably have just hard-coded ‘master’, but the automatic default is now ‘main’. And of course, the default branch could be something else entirely.

We can grab the default branch for each repo from the GitHub API using the excellent {gh} package by Gábor Csárdi, Jenny Bryan and Hadley Wickham. You’ll need to do some setup to use it yourself.

The key function is gh(), to which you can pass a GET request for the information we want: GET /repos/{owner}/{repo}. We can iterate for each repo by passing each owner and repo name in turn. It returns a list object with lots of information about the repo.

I’ve created ‘possibly’ function variants with {purrr} so that any errors in the process are handled by returning NA, rather than breaking the loop, which would kill the process.

# Create 'try' function versions
map2_possibly <- possibly(map2, NA_real_)
gh_possibly <- possibly(gh, NA_real_)

# Function: fetch repo details, print message on action
get_repo <- function(owner, repo) {
  cat(paste0("[", Sys.time(), "]"), paste0(owner, "/", repo), "\n")
  gh_possibly("GET /repos/{owner}/{repo}", owner = owner, repo = repo) 
}

maybe_zzz <- has_repo %>%
  mutate(
    repo_deets =  map2_possibly(
      has_repo$owner, has_repo$repo, get_repo
    )
  ) %>% 
  mutate(
    default_branch = map(
      repo_deets, ~pluck(.x, "default_branch")
    ),
    default_branch = pluck(default_branch, 1),
    zzz_url = paste0(
      "https://raw.githubusercontent.com/",
      owner, "/", repo, "/", default_branch, "/R/zzz.R"
    )
  )

So now we have a column with the returned repo information, the extracted default branch name and a URL that points to a potential zzz.R file in that repo.

head(maybe_zzz)

## # A tibble: 6 × 6
##   Package      owner          repo         repo_deets  default_branch zzz_url   
##   <chr>        <chr>          <chr>        <list>      <chr>          <chr>     
## 1 AATtools     Spiritspeak    AATtools     <gh_rspns … master         https://r…
## 2 abbyyR       soodoku        abbyyR       <gh_rspns … master         https://r…
## 3 abctools     dennisprangle  abctools     <gh_rspns … master         https://r…
## 4 abdiv        kylebittinger  abdiv        <gh_rspns … master         https://r…
## 5 abess        abess-team     abess        <gh_rspns … master         https://r…
## 6 ABHgenotypeR StefanReuscher ABHgenotypeR <gh_rspns … master         https://r…

Status codes

Now we can check the status code for each of the URLs we’ve built. A return of 200 tells us that the file exists and 404 means it doesn’t.⁴ Again, we can prevent the loop breaking on error by creating a ‘possibly’ version of map().

library(httr)  # for status_code()

map_possibly <- possibly(map, NA_character_)

maybe_zzz_status <- maybe_zzz %>% 
  mutate(
    status = map_possibly(
      zzz_url, ~status_code(GET(.x))
    )
  ) %>% 
  unnest(status)

count(maybe_zzz_status, status)

## # A tibble: 2 × 2
##   status     n
##    <int> <int>
## 1    200  1237
## 2    404  5332

Okay, great, we’ve got over a thousand zzz.R files.

Read content

Now we know which packages have a zzz.R file, we can use readLines() to grab their content from their URL, which again we can protect from errors with purrr::possibly().

Note that I’ve created a special version of readLines() that reports to the user the path being checked, but also has a random delay. This is to dampen the impact on GitHub’s servers.

# Function: readLines() but with a pause and message
readLines_delay <- function(path) {
  sample(1:3, 1)
  cat(paste0("[", Sys.time(), "]"), path, "\n")
  readLines(path, warn = FALSE)
}

readLines_delay_possibly <- possibly(readLines_delay, NA_character_)

fosho_zzz <- maybe_zzz_status %>% 
  select(-repo_deets) %>% 
  filter(status == 200) %>%  # just the 
  mutate(lines = map_possibly(zzz_url, readLines_delay_possibly))

dim(fosho_zzz)

So now we have a dataframe with a row per package and a list-column containing the R code in the zzz.R file.

Startup messages

Finally, we can find out which packages have a packageStartupMessage() call inside their zzz.R.

has_psm <- fosho_zzz %>% 
  select(Package, lines) %>%
  unnest(lines) %>%
  filter(str_detect(lines, "packageStartupMessage")) %>% 
  mutate(lines = str_remove_all(lines, " ")) %>%
  distinct(Package) %>% 
  pull()

fosho_psm <- filter(fosho_zzz, Package %in% has_psm)

So we started with 18338 CRAN packages and have winnowed it to down to 467 (3%) that have a call to packageStartupMessage() in their zzz.R.

Table of results

I could provide a table with all the zzz.R scripts that I collected, but I don’t want to break any licenses by reproducing them all here. Instead, here’s an interactive table that links to the GitHub page for each zzz.R file.

library(reactable)
reactable(
  data = fosho_zzz %>% select(package = Package, owner, url = zzz_url),
  searchable = TRUE,
  paginationType = "jump",
  defaultPageSize = 10,
  columns = list(
    url = colDef(cell = function(value) {
      htmltools::tags$a(href = value, target = "_blank", "zzz.R")
    })
  )
)

Patterns

I had a scan through the scripts and found some frequent uses of packageStartupMessages() to:

• show a basic salutation (e.g. {afex})
• show the version number, a check to see if the user has the latest version, sometimes a prompt to download the latest version for them (e.g. {vistributions}), sometimes a note that the package has been superseded by another (e.g. {drake})
• links to guidance, examples, documentation (e.g. {bayesplot})
• provide a citation or author names (e.g. {unvotes})
• link to issue tracking or bug reporting (e.g. {timeperiodsR})
• check for required supplementary software (e.g. {DALY})
• remind of the need for credentials or keys for packages that access APIS, for example (e.g. {trainR})
• provide terms of use, warranties, licenses, etc (e.g. {emmeans})

I was also interested to see:

• a random tip, so you get something new each time you attach the package (e.g. {shinyjs})
• appeals for GitHub stars (e.g. {sigminer})
• links to purchasable course materials (e.g. {anomalise})

And perhaps the most self-aware were several packages that reminded the user that they can turn off startup messages with suppressPackageStartupMessages() if the messages get too annoying (e.g. {dendextend}).

A few interesting specifics (possible spoiler alerts!):

• {bayestestR} and {sjmisc} have displays a special Star Wars message on a certain day of the year…
• {SHT} and {symengine} load ASCII art, as does {BetaBit}, which also prompts the user for a game they’d like to play
• {depigner} says ‘Welcome to depigner: we are here to un-stress you!’
• {mde} has a friendly ‘Happy Exploration :)’ salutation and {manymodelr} says ‘Happy Modelling! :)’
• {sjPLot} says ‘#refugeeswelcome’

You can use the interactive table above to reach each of the zzz.R files for these packages, or have a sift through yourself to see what you can find.