turtletopia/woodendesc

Get the available packages and their version codes as well as their dependencies from any R repository with unified API.

woodendesc's Issues

Implement dependency filter

It should be able to filter specific dependencies and take "strong", "most", and "all" as keywords.

Handle 403 error with GitHub

Exceeded rate limit is a different error to 404, so inform the user properly. In fact, handle all kinds of errors properly.

Add functions for core packages

The best bet is probably to use installed.packages(priority = "base"). The implementations would be as follows:

wood_core_packages <- function() {
  rownames(installed.packages(priority = "base"))
}

wood_core_version <- function(package) {
  installed.packages(priority = "base")[package, "Version"]
}

wood_core_dependencies <- function(package) {
  # Some function that extracts dependencies here
  extract_dependencies(installed.packages(priority = "base")[package, ])
}

Plus some argument checks, docs, and tests; obviously.

Use more aggresive caching for GitHub

When listing repos, we can avoid performing pagination by sorting by created or updated instead of full_name. Or perhaps use conditional requests (https://docs.github.com/en/rest/overview/resources-in-the-rest-api#conditional-requests) to check if the cache expired. Or, preferably, combine both.
If sorting by updated, we can also optimize checking for DESCRIPTION files; re-check only those that were updated since then.

Other git repositories to consider

There's a whole list of git repositories. Below are the selected ones (list not exhaustive):

• Bitbucket (e.g. assertive)
• SourceForge

Implement functions for Github

If the tags can be considered equal to releases, then it should be non-trivial to implement packages, versions, and dependencies. The username should be a requirement similar to the universe for R-universe.

Side note, check other version control systems, maybe they are implementable too?

• github_packages()
• github_tags()
• github_versions() (by checking DESCRIPTION files for each tag)
• github_latest() (would return version code for the current commit; not a tag)
• github_dependencies() (for any tag)

Branch name is required to extract DESCRIPTION, which is needed for both version and dependencies, but it is possible to try and guess branch name first (master or main) and only make query to user repo data for main branch name if no success. If DESCRIPTION not found even then, throw an error and suggest making an issue (maybe DESCRIPTION is in a different path?).

It is also possible to save pagination data when reading repos for a user. The first reading must be done from the first page, as we don't know how many pages there are. However, when searching for e.g. main branch name of a repository, we could stop iterating through pages after finding the package. We'd have to keep track of page read time (perhaps use page as cache path parameter?).

Add classes to return values

Mostly for dependencies and lists of dependencies (vide wood_dependencies()). wood_deps and wood_dep_list?

Implement `squash.wood_dep_list()`

It would merge all data frames (wood_deps) in a list into one long data frame with additional column telling which package is it. The problem is, what should it be called? package is taken already.

Make error messages compliant with tidyverse style guide

This way they'd be more descriptive. Use this: https://style.tidyverse.org/error-messages.html.

Remove `donttest` from local and core functions

If possible, try to avoid donttest and especially dontrun in examples.

Implement functions for Gitlab

It has a similar structure to GitHub, so perhaps there should be a general structure for repositories, if they have the same features.

As for DESCRIPTION file, it's available raw through e.g. https://gitlab.com/r-packages/rock/-/raw/dev/DESCRIPTION for package rock.

Add `print` and `summary` methods to custom classes

Implement missing tests

• wood_versions()
• wood_dependencies()
• squash()
• filter_dependencies()
• github_tags()
• github_versions()
• github_latest()
• interpret_repos()
• query_maker()
• print.wood_deps()
• print.wood_dep_squashed()
• print.wood_dep_list()
• summary.wood_deps()
• summary.wood_dep_squashed()
• summary.wood_dep_list()

Standardize parameter documentation

Using [ and ] around parameter types is deprecated, remove it where applicable.

Implement `squash.wood_deps()`

It would use ... to squash multiple wood_deps objects (add ...length() check to squash.wood_dep_list()).

Implement namespace functions

Add another type of functions, wood_xxx_namespace(). They would extract both exports and imports from NAMESPACE file. The return object would have a class so that several methods could be implemented (e.g. extraction of exported names, squashing several namespaces, etc.).

Why though? Because I've got a plan for a package and it would work better to place this functionality in woodendesc.

Not needed for the release, might wait until update to plan the API better.

Github authentication

Consider authentication. Wait for {woodendesc} users to show that there's a need for it.

Add argument checks

All the checks of type length(param) == 1, typeof(param) == "character", etc...

• bioc
• core
• cran
• github
• local
• runiverse
• url
• wood
• filter_dependencies()
• squash()