Use stamp rt

NAMESPACE

@@ -19,7 +19,7 @@ export(get_from_pipenv)
 export(get_github_creds)
 export(get_latest_pip_release)
 export(get_latest_ppp_versions)
-export(get_pins_boards)
+export(get_pip_folders)
 export(get_pip_releases)
 export(get_pipenv)
 export(get_ppp_versions)
@@ -55,7 +55,7 @@ export(remove_dir)
 export(remove_pip_release)
 export(save_to_gh)
 export(set_in_pipenv)
-export(set_pip_boards)
+export(set_pip_folders)
 export(setup_working_release)
 export(sync_release_branch)
 export(update_branches)

R/get_from_gh.R

@@ -275,12 +275,6 @@ get_file_info_from_gh <- function(owner= getOption("pipfun.ghowner"),
 
 
   creds = get_github_creds()
-
-  # alternative
-  # gh::gh("GET /repos/:owner/:repo/contents/:path",
-  #        owner = owner, repo = repo, path = path, ref = ref,
-  #        .token = Sys.getenv("GITHUB_PAT"))
-
   mt <- gh::gh(
     "GET /repos/{owner}/{repo}/contents/{file_path}",
     owner     = owner,

R/load_from_gh.R

@@ -48,7 +48,9 @@ load_from_gh <- function(measure,
 
 
   #   _____________________________________________________
-  #   get data                                            ####
+  #   get data   ####
+
+
 
   root <- "https://raw.githubusercontent.com"
   path  <- glue("{root}/{owner}/{repo}/{tag}/{filename}")

R/working_release.R

@@ -26,70 +26,70 @@
 #' try(setup_working_release())
 #' }
 setup_working_release <- function(release  = NULL,
-                                 identity  = getOption("pipfun.identities"),
-                                 force     = FALSE,
-                                 owner     = getOption("pipfun.ghowner"),
-                                 repo      = "pip_info",
-                                 file_path = "releases.csv",
-                                 branch    = "releases",
-                                 verbose   = getOption("pipfun.verbose"),
-                                 ppp       = getOption("pipfun.ppps"),
-                                 creds     = NULL,
-                                 main_dir  = getOption("pipfun.main_dir"),
-                                 ...) {
+                                  identity  = getOption("pipfun.identities"),
+                                  force     = FALSE,
+                                  owner     = getOption("pipfun.ghowner"),
+                                  repo      = "pip_info",
+                                  file_path = "releases.csv",
+                                  branch    = "releases",
+                                  verbose   = getOption("pipfun.verbose"),
+                                  ppp       = getOption("pipfun.ppps"),
+                                  creds     = NULL,
+                                  main_dir  = getOption("pipfun.main_dir"),
+                                  ...) {
+
   identity <- match.arg(identity)
-  ppp      <- ppp[1]
+  ppp <- ppp[1]
   if (!ppp %in% getOption("pipfun.ppps")) {
     cli::cli_abort(c("Wrong PPP value",
                      i = "PPP values must be {.or {getOption(\"pipfun.ppps\")}}"))
   }
 
+  pr <- if (is.null(release)) {
+    get_latest_pip_release(identity = identity,
+                           owner     = owner,
+                           repo      = repo,
+                           file_path = file_path,
+                           branch    = branch,
+                           verbose   = verbose,
+                           creds     = creds)
+  } else {
+    get_pip_releases(owner     = owner,
+                     repo      = repo,
+                     file_path = file_path,
+                     branch    = branch,
+                     verbose   = verbose,
+                     creds     = creds) |>
+      find_release(release = release, identity = identity)
+  }
 
-  pr <-
-    if (is.null(release)) {
-      get_latest_pip_release(identity = identity,
-                             owner     = owner,
-                             repo      = repo,
-                             file_path = file_path,
-                             branch    = branch,
-                             verbose   = verbose,
-                             creds     = creds)
-    } else {
-      get_pip_releases(owner     = owner,
-                       repo      = repo,
-                       file_path = file_path,
-                       branch    = branch,
-                       verbose   = verbose,
-                       creds     = creds) |>
-        find_release(release = release,
-                     identity = identity)
-    }
-
-  # create globals
-  # for now. Dirs should be created elsewhere
+  # create globals (no dir creation here)
   gls <- pip_create_globals(create_dir = FALSE,
                             vintage    = list(release = release,
                                               ppp_year = ppp,
                                               identity = identity),
                             verbose = verbose,
                             ...)
 
-  # setup working release
+  # setup working release info
   wr <- list(release  = pr[, release],
              identity = pr[, identity],
              ppp      = ppp)
 
-  boards <- set_pip_boards(main_dir = main_dir,
-                           release = pr[, release],
-                           identity = pr[, identity])
+  # get directory paths (no pins)
+  folder_paths <- set_pip_folders(main_dir = main_dir,
+                                 release = pr[, release],
+                                 identity = pr[, identity])
 
+  # save to .pipenv
+  rlang::env_poke(.pipenv, "stamp_root", main_dir)
   rlang::env_poke(.pipenv, "wrk_release", wr)
   rlang::env_poke(.pipenv, "gls", gls)
-  rlang::env_poke(.pipenv, "pins_boards", boards)
+  rlang::env_poke(.pipenv, "folder_paths", folder_paths)  # updated
 
   if (verbose) {
     cli::cli_alert_info("PIP working release setup to {.field {wr$release}-{wr$identity}}")
-    print(boards)
+    print(folder_paths)
   }
 
   invisible(wr)
@@ -98,98 +98,84 @@ setup_working_release <- function(release  = NULL,
 
 
 
-#' set pins board
+#' Set PIP directory paths
 #'
-#' set all the directory paths that contain pins boards for pip. It should be
-#' used inside [setup_working_release] but it could be used interactively for
-#' testing purposes.
+#' This function creates all necessary directories for a PIP release
+#' and returns a named list of paths.
 #'
 #' @inheritParams setup_working_release
-#'
-#' @returns lists of pins boards
+#' @returns Named list of directory paths
 #' @export
-#'
-#' @examples
-#' set_pip_boards()
-set_pip_boards <- function(main_dir  = getOption("pipfun.main_dir"),
-                           release  = NULL,
-                           identity  = getOption("pipfun.identities")) {
+set_pip_folders <- function(main_dir  = getOption("pipfun.main_dir"),
+                            release  = NULL,
+                            identity  = getOption("pipfun.identities")) {
 
   identity <- match.arg(identity)
   if (is.null(release)) {
-    release <- get_latest_pip_release() |>
-      _[, release]
+    release <- get_latest_pip_release() |> _[, release]
   }
 
-  rt      <- glue("{release}_{identity}")
+  rt <- glue("{release}_{identity}")
 
-  # Aux data ---------
+  # Aux data
   aux_internal <- c("aux_data", "aux_metadata")
-  aux_dir <- fs::path(main_dir, "aux_repository", aux_internal) |>
-    fs::path(rt) |>
+  aux_dir <- fs::path(main_dir, "aux_repository", aux_internal, rt) |>
     fs::dir_create()
 
-  aux_data <- pins::board_folder(aux_dir[1], TRUE)
-  aux_metadata <- pins::board_folder(aux_dir[2], TRUE)
-
-  # DLW data ---------
-  dlw_dir <- fs::path(main_dir, "dlw_repository") |>
+  # DLW data
+  dlw_dir           <- fs::path(main_dir, "dlw_repository") |>
     fs::dir_create(recurse = TRUE)
-
   dlw_data_dir      <- fs::path(dlw_dir, "dlw_data") |>
     fs::dir_create(recurse = TRUE)
   dlw_inventory_dir <- fs::path(dlw_dir, "dlw_inventory") |>
     fs::dir_create(recurse = TRUE)
   dlw_metadata_dir  <- fs::path(dlw_dir, "dlw_metadata", rt) |>
     fs::dir_create(recurse = TRUE)
 
-  dlw_data      <- pins::board_folder(dlw_data_dir, TRUE)
-  dlw_inventory <- pins::board_folder(dlw_inventory_dir, TRUE)
-  dlw_metadata  <- pins::board_folder(dlw_metadata_dir, TRUE)
-
-  # PIP data ------
-  pip_dir <- fs::path(main_dir, "pip_repository") |>
+  # PIP data
+  pip_dir                  <- fs::path(main_dir, "pip_repository") |>
     fs::dir_create(recurse = TRUE)
-
-  pip_data_dir      <- fs::path(pip_dir, "pip_data", "surveys")|>
+  pip_data_dir             <- fs::path(pip_dir, "pip_data", "surveys") |>
     fs::dir_create(recurse = TRUE)
-
-  pip_master_inventory_dir  <-
-    fs::path(pip_dir, "pip_data", "master_inventory")|>
+  pip_master_inventory_dir <- fs::path(pip_dir, "pip_data", "master_inventory") |>
     fs::dir_create(recurse = TRUE)
-
-  pip_metadata_dir  <- fs::path(pip_dir, "pip_data", "surveys_metadata", rt) |>
+  pip_metadata_dir         <- fs::path(pip_dir, "pip_data", "surveys_metadata", rt) |>
     fs::dir_create(recurse = TRUE)
-
-  pip_inventory_dir <- fs::path(pip_dir, "pip_inventory", rt) |>
+  pip_inventory_dir        <- fs::path(pip_dir, "pip_inventory", rt) |>
     fs::dir_create(recurse = TRUE)
 
-  pip_data             <- pins::board_folder(pip_data_dir, TRUE)
-  pip_metadata         <- pins::board_folder(pip_metadata_dir, TRUE)
-  pip_inventory        <- pins::board_folder(pip_inventory_dir, TRUE)
-  pip_master_inventory <- pins::board_folder(pip_master_inventory_dir, TRUE)
-
+  # Determine stamp project root (the overall PIP data directory)
+  stamp_root <- main_dir
 
-  boards <- list(aux_data      = aux_data,
-                 aux_metadata  = aux_metadata,
-                 dlw_data      = dlw_data,
-                 dlw_metadata  = dlw_metadata,
-                 dlw_inventory = dlw_inventory,
-                 pip_data      = pip_data,
-                 pip_metadata  = pip_metadata,
-                 pip_inventory = pip_inventory,
-                 pip_master_inventory = pip_master_inventory)
+  # Initialize stamp if needed
+  if (!fs::dir_exists(fs::path(stamp_root, ".stamp"))) {
+    stamp::st_init(root = stamp_root)
+  }
 
-  class(boards) <- "pip_boards"
-  boards
+  # Return named list of paths
+  folder_paths <- list(
+    stamp_root    = stamp_root,
+    aux_data      = aux_dir[1],
+    aux_metadata  = aux_dir[2],
+    dlw_data      = dlw_data_dir,
+    dlw_inventory = dlw_inventory_dir,
+    dlw_metadata  = dlw_metadata_dir,
+    pip_data      = pip_data_dir,
+    pip_metadata  = pip_metadata_dir,
+    pip_inventory = pip_inventory_dir,
+    pip_master_inventory = pip_master_inventory_dir
+  )
+
+  class(folder_paths) <- "pip_folder_paths"
+  folder_paths
 }
 
+
 #' get working release in PIP functions
 #'
 #' You can place this function at the beginning of any of your PIP function to
 #' work with the working release
 #'
-#' @inheritParams setup_working_release
 #' @param name character: Name of the working release object. default is
 #'   "wrk_release" and you should leave it like that
 #'
@@ -223,36 +209,45 @@ get_wrk_release <- function(name = "wrk_release",
 
 
 
-#' Get PIP pins boards from pipenv environment
-#' @param board character: name of the PIP board you want to filter
-#' @param name character: Name of the pins boards that you want to assign to the
-#'   parent.frame() that call this function. default is "pins_boards" and you
-#'   should leave it like that. this is just an argument for developers.
-#' @inheritParams setup_working_release
+#' Get PIP folder paths from .pipenv
 #'
-#' @returns list of pins boards
+#' This function retrieves the folder paths that were set up for a PIP release.
+#'
+#' @param folder character: optional, name of a specific folder to retrieve.
+#'   If NULL (default), returns all folder paths.
+#' @param name character: name of the object to assign to the calling environment.
+#'   Default is `"pip_folders"`.
+#' @param verbose logical: whether to print info about the folders retrieved. Default is FALSE
+#'
+#' @return A named list of folder paths or a single folder path if `folder` is specified.
 #' @export
-#' @rdname get_wrk_release
-get_pins_boards <- function(board = NULL,
-                            name = "pins_boards",
-                           verbose  = getOption("pipfun.verbose")) {
-  pins_boards <- get_from_pipenv("pins_boards")
-  if (is.null(pins_boards)) {
+get_pip_folders <- function(folder = NULL,
+                            name = "pip_folders",
+                            verbose = FALSE) {
+
+  pip_folders <- get_from_pipenv("folder_paths")
+
+  if (is.null(pip_folders)) {
     cli::cli_abort(
-      c(x = "PIP pins boards have not been set up",
+      c(x = "PIP folder paths have not been set up",
         i = "You need to set a working release with {.code pipfun::setup_working_release()}"))
-  } else {
-    if (verbose) pins_boards
   }
 
-  assign(name, pins_boards, envir = parent.frame())
+  if (verbose) {
+    cli::cli_alert_info("Retrieved PIP folder paths")
+    print(pip_folders)
+  }
+
+  # Assign to parent.frame for developer convenience
+  assign(name,
+         pip_folders,
+         envir = parent.frame())
 
-  if (is.null(board)) return(invisible(pins_boards))
+  if (is.null(folder)) return(invisible(pip_folders))
 
-  if (!(board %in% names(pins_boards))) {
-    cli::cli_abort("{.field {board}} is not available in {.field pins_board}")
+  if (!(folder %in% names(pip_folders))) {
+    cli::cli_abort("{.field {folder}} is not available in {.field pip_folders}")
   }
 
-  pins_boards[[board]]
-
+  invisible(pip_folders[[folder]])
 }