Prepare to auto-document internal functions

DESCRIPTION

@@ -34,7 +34,6 @@ Imports:
     tibble,
     tidyr,
     usethis,
-    utils,
     yaml
 Suggests:
     covr,

R/aaa-shared_params.R

@@ -16,6 +16,7 @@
 #'   files.
 #' @param rapid_file (`character(1)` or `fs_path`) The path to the R API
 #'   definition (rapid) file.
+#' @param to_collapse (`character`) The character vector to collapse.
 #'
 #' @name .shared-params
 #' @keywords internal

R/as_bk_data.R

@@ -3,8 +3,7 @@
 #' Convert `rapid` objects to lists of properties to use in beekeeper templates.
 #'
 #' @inheritParams rlang::args_dots_empty
-#' @param x The object to coerce. Currently supports conversion of
-#'   [rapid::class_security_schemes()] objects.
+#' @param x The object to coerce.
 #'
 #' @returns A list.
 #' @keywords internal

R/beekeeper-package.R

@@ -1,19 +1,19 @@
 #' @keywords internal
 "_PACKAGE"
 
+## Force installation: nectar, testthat
+## S7 classes: rapid, S7
+## Use as pronoun: rlang::.data
 ## usethis namespace: start
-## Force installation
 #' @importFrom nectar req_prepare
 #' @importFrom testthat test_that
-## S7 classes
 #' @importFrom rapid class_api_key_security_scheme
 #' @importFrom rapid class_paths
 #' @importFrom rapid class_security_scheme_details
 #' @importFrom rapid class_security_schemes
 #' @importFrom S7 class_any
 #' @importFrom S7 class_data.frame
 #' @importFrom S7 class_list
-## Use as pronoun
 #' @importFrom rlang .data
 ## usethis namespace: end
 NULL

R/generate_pkg-paths.R

@@ -30,34 +30,42 @@ S7::method(as_bk_data, class_paths) <- function(x) {
   if (!length(x)) {
     return(list())
   }
-  paths_df <- .paths_to_clean_df(x)
-  result <- purrr::pmap(paths_df, .path_row_to_list)
-  names(result) <- paths_df$operation_id
+  operations_df <- .paths_to_clean_df(x)
+  result <- purrr::pmap(operations_df, .path_row_to_list)
+  names(result) <- operations_df$operation_id
   result
 }
 
-.paths_to_clean_df <- function(x) {
-  x <- tibble::as_tibble(x) |>
+.paths_to_clean_df <- function(paths) {
+  operations_df <- tibble::as_tibble(paths) |>
     tidyr::unnest("operations")
-  if (length(x$deprecated)) {
-    x <- x[!x$deprecated, ]
+  if (length(operations_df$deprecated)) {
+    operations_df <- operations_df[!operations_df$deprecated, ]
   }
-  x$deprecated <- NULL
-  x$tags <- .paths_fill_tags(x$tags)
-  x$operation_id <- .paths_fill_operation_id(
-    x$operation_id,
-    x$endpoint,
-    x$operation
+  operations_df$deprecated <- NULL
+  operations_df$tags <- .paths_fill_tags(operations_df$tags)
+  operations_df$operation_id <- .paths_fill_operation_id(
+    operations_df$operation_id,
+    operations_df$endpoint,
+    operations_df$operation
   )
-  x$summary <- .paths_fill_summary(
-    x$summary,
-    x$endpoint,
-    x$operation
+  operations_df$operation_summary <- .paths_fill_summary(
+    operations_df$summary,
+    operations_df$endpoint,
+    operations_df$operation
   )
-  x$description <- .paths_fill_descriptions(x$description, x$summary)
+  operations_df$summary <- NULL
+  operations_df$operation_description <- .paths_fill_descriptions(
+    operations_df$description,
+    operations_df$operation_summary
+  )
+  operations_df$description <- NULL
   # TODO: Deal with x$global_parameters if present
-  x$parameters <- purrr::map(x$parameters, .prepare_params_df)
-  return(x)
+  operations_df$parameters <- purrr::map(
+    operations_df$parameters,
+    .prepare_params_df
+  )
+  return(operations_df)
 }
 
 ### fill data ------------------------------------------------------------------
@@ -68,25 +76,27 @@ S7::method(as_bk_data, class_paths) <- function(x) {
   return(.to_snake(tags))
 }
 
-.paths_fill_operation_id <- function(operation_id, endpoint, method) {
-  .coalesce(
-    .to_snake(operation_id),
-    glue::glue("{method}_{.to_snake(endpoint)}")
-  )
+.paths_fill_operation_id <- function(operation_ids, endpoints, methods) {
+  .to_snake(operation_ids) %|% glue::glue("{methods}_{.to_snake(endpoints)}")
 }
 
-.paths_fill_summary <- function(summary, endpoint, method) {
-  endpoint_spaced <- stringr::str_replace_all(.to_snake(endpoint), "_", " ")
-  .coalesce(
-    stringr::str_squish(summary),
-    stringr::str_to_sentence(glue::glue("{method} {endpoint_spaced}"))
-  )
+.paths_fill_summary <- function(operation_summaries, endpoints, methods) {
+  endpoints_spaced <- stringr::str_replace_all(.to_snake(endpoints), "_", " ")
+  stringr::str_squish(operation_summaries) %|%
+    stringr::str_to_sentence(glue::glue("{methods} {endpoints_spaced}"))
 }
 
-.paths_fill_descriptions <- function(descriptions, summaries) {
-  descriptions[is.na(descriptions)] <- summaries[is.na(descriptions)]
-  descriptions[is.na(descriptions)] <- ""
-  return(stringr::str_squish(descriptions))
+.paths_fill_descriptions <- function(
+  operation_descriptions,
+  operation_summaries
+) {
+  operation_descriptions[is.na(
+    operation_descriptions
+  )] <- operation_summaries[is.na(
+    operation_descriptions
+  )]
+  operation_descriptions[is.na(operation_descriptions)] <- ""
+  return(stringr::str_squish(operation_descriptions))
 }
 
 ### create template data -------------------------------------------------------
@@ -95,8 +105,8 @@ S7::method(as_bk_data, class_paths) <- function(x) {
   operation_id,
   endpoint,
   operation,
-  summary,
-  description,
+  operation_summary,
+  operation_description,
   tags,
   parameters,
   ...
@@ -106,8 +116,8 @@ S7::method(as_bk_data, class_paths) <- function(x) {
     tag = tags,
     path = .path_as_arg(endpoint, parameters),
     method = operation,
-    summary = summary,
-    description = description,
+    operation_summary = operation_summary,
+    operation_description = operation_description,
     params = .params_to_list(parameters),
     params_query_raw = .extract_params_by_location(parameters, "query"),
     params_header_raw = .extract_params_by_location(parameters, "header"),
@@ -219,10 +229,6 @@ S7::method(as_bk_data, class_paths) <- function(x) {
   return(glue::glue('c("{path}", {params})'))
 }
 
-.collapse_comma_self_equal <- function(x) {
-  .collapse_comma(glue::glue("{x} = {x}"))
-}
-
 # generate files ---------------------------------------------------------------
 
 .generate_paths_files <- function(
@@ -275,11 +281,11 @@ S7::method(as_bk_data, class_paths) <- function(x) {
 }
 
 .params_to_args <- function(params) {
-  .collapse_comma(purrr::map_chr(params, "name")) %|"|% character()
+  .collapse_comma(purrr::map_chr(params, "name")) %|a|% character()
 }
 
 .params_to_named_args <- function(params) {
-  .collapse_comma_self_equal(purrr::map_chr(params, "name")) %|"|% character()
+  .collapse_comma_self_equal(purrr::map_chr(params, "name")) %|a|% character()
 }
 
 .remove_security_args <- function(params, security_args) {
@@ -292,7 +298,7 @@ S7::method(as_bk_data, class_paths) <- function(x) {
 }
 
 .prep_param_args <- function(params, security_args) {
-  .collapse_comma_self_equal(setdiff(params, security_args)) %|"|% character()
+  .collapse_comma_self_equal(setdiff(params, security_args)) %|a|% character()
 }
 
 .params_to_validations <- function(params) {

R/generate_pkg-security.R

@@ -26,47 +26,55 @@ S7::method(as_bk_data, class_security_schemes) <- function(x) {
   if (!length(x)) {
     return(list())
   }
-  security_schemes <- .security_schemes_collect(x)
-  return(.security_scheme_collection_finalize(security_schemes))
+  security_scheme_collection <- .security_schemes_collect(x)
+  return(.security_scheme_collection_finalize(security_scheme_collection))
 }
 
-.security_schemes_collect <- function(x) {
+.security_schemes_collect <- function(security_schemes) {
   purrr::pmap(
     list(
-      x@name,
-      x@details,
-      x@description %|0|% rep(NA_character_, length(x@name))
+      security_schemes@name,
+      security_schemes@details,
+      security_schemes@description %|0|%
+        rep(NA_character_, length(security_schemes@name))
     ),
     .security_scheme_rotate
   )
 }
 
-.security_scheme_rotate <- function(name, details, description) {
-  security_scheme <- c(
+.security_scheme_rotate <- function(
+  security_scheme_name,
+  security_scheme_details,
+  security_scheme_description
+) {
+  security_scheme_list <- c(
     list(
-      name = .to_snake(name),
-      description = description
+      name = .to_snake(security_scheme_name),
+      description = security_scheme_description
     ),
-    as_bk_data(details)
+    as_bk_data(security_scheme_details)
   )
-  security_scheme$description <- .security_scheme_description_fill(
-    description,
-    security_scheme$type
+  security_scheme_list$description <- .security_scheme_description_fill(
+    security_scheme_description,
+    security_scheme_list$type
   )
-  return(security_scheme)
+  return(security_scheme_list)
 }
 
-.security_scheme_description_fill <- function(description, type) {
-  if (is.na(description)) {
+.security_scheme_description_fill <- function(
+  security_scheme_description,
+  security_scheme_type
+) {
+  if (is.na(security_scheme_description)) {
     return(
       switch(
-        type,
+        security_scheme_type,
         api_key = .security_scheme_description_api_key,
         NA_character_
       )
     )
   }
-  return(description) # nocov
+  return(security_scheme_description) # nocov
 }
 
 .security_scheme_description_api_key <- paste(
@@ -75,49 +83,58 @@ S7::method(as_bk_data, class_security_schemes) <- function(x) {
   "Check the API documentation for details."
 )
 
-.security_scheme_collection_finalize <- function(security_schemes) {
+.security_scheme_collection_finalize <- function(security_scheme_collection) {
   security_scheme_data <- c(
     list(
       has_security = TRUE,
-      security_schemes = security_schemes
+      security_schemes = security_scheme_collection
     ),
-    .security_args_compile(security_schemes)
+    .security_args_compile(security_scheme_collection)
   )
   return(security_scheme_data)
 }
 
-.security_args_compile <- function(security_schemes) {
-  security_args <- sort(unique(purrr::map_chr(security_schemes, "arg_name")))
+.security_args_compile <- function(security_scheme_collection) {
+  security_args <- sort(unique(purrr::map_chr(
+    security_scheme_collection,
+    "arg_name"
+  )))
   return(list(
     security_arg_names = security_args,
     security_arg_list = .collapse_comma(glue::glue(
       "{security_args} = {security_args}"
     )),
     security_arg_helps = .generate_security_arg_help(
-      security_schemes,
+      security_scheme_collection,
       security_args
     ),
     security_arg_nulls = .collapse_comma(glue::glue("{security_args} = NULL"))
   ))
 }
 
-.generate_security_arg_help <- function(security_schemes, security_args) {
-  security_arg_description <- rlang::set_names(
-    purrr::map_chr(security_schemes, "description"),
-    purrr::map_chr(security_schemes, "arg_name")
+.generate_security_arg_help <- function(
+  security_scheme_collection,
+  security_args
+) {
+  security_arg_descriptions <- rlang::set_names(
+    purrr::map_chr(security_scheme_collection, "description"),
+    purrr::map_chr(security_scheme_collection, "arg_name")
   )
-  security_arg_description <- unname(security_arg_description[security_args])
+  security_arg_descriptions <- unname(security_arg_descriptions[security_args])
   return(
     purrr::map2(
-      security_arg_description,
+      security_arg_descriptions,
       security_args,
       .security_arg_description_clean
     )
   )
 }
 
-.security_arg_description_clean <- function(arg_description, arg_name) {
-  list(name = arg_name, description = arg_description)
+.security_arg_description_clean <- function(
+  security_arg_description,
+  security_arg_name
+) {
+  list(name = security_arg_name, description = security_arg_description)
 }
 
 S7::method(as_bk_data, class_security_scheme_details) <- function(x) {

R/generate_pkg-setup.R

@@ -62,13 +62,17 @@ read_config <- function(pkg_dir = ".", config_file = "_beekeeper.yml") {
 .stabilize_config <- function(config) {
   config$api_title <- stbl::stabilize_character_scalar(config$api_title)
   config$api_abbr <- stbl::stabilize_character_scalar(config$api_abbr)
-  config$api_version <- stbl::stabilize_character_scalar(config$api_version)
-  config$rapid_file <- stbl::stabilize_character_scalar(config$rapid_file)
-  config$updated_on <- strptime(
-    config$updated_on,
-    format = "%Y-%m-%d %H:%M:%S",
-    tz = "UTC"
+  config$api_version <- stbl::stabilize_character_scalar(
+    config$api_version,
+    allow_null = TRUE
   )
+  config$rapid_file <- stbl::stabilize_character_scalar(config$rapid_file)
+  config$updated_on <- config$updated_on %&&%
+    strptime(
+      config$updated_on,
+      format = "%Y-%m-%d %H:%M:%S",
+      tz = "UTC"
+    )
   return(config)
 }