Change built to completed, started to dispatched

NAMESPACE

@@ -246,12 +246,12 @@ S3method(target_needs_worker,tar_builder)
 S3method(target_needs_worker,tar_pattern)
 S3method(target_patternview_canceled,default)
 S3method(target_patternview_canceled,tar_branch)
+S3method(target_patternview_dispatched,default)
+S3method(target_patternview_dispatched,tar_branch)
 S3method(target_patternview_errored,default)
 S3method(target_patternview_errored,tar_branch)
 S3method(target_patternview_meta,default)
 S3method(target_patternview_meta,tar_branch)
-S3method(target_patternview_started,default)
-S3method(target_patternview_started,tar_branch)
 S3method(target_prepare,default)
 S3method(target_prepare,tar_builder)
 S3method(target_produce_junction,tar_pattern)

R/class_branch.R

@@ -106,13 +106,13 @@ target_patternview_meta.tar_branch <- function(target, pipeline, meta) {
 }
 
 #' @export
-target_patternview_started.tar_branch <- function(
+target_patternview_dispatched.tar_branch <- function(
   target,
   pipeline,
   scheduler
 ) {
   parent <- pipeline_get_target(pipeline, target_get_parent(target))
-  patternview_register_started(parent$patternview, parent, scheduler)
+  patternview_register_dispatched(parent$patternview, parent, scheduler)
 }
 
 #' @export

R/class_builder.R

@@ -50,9 +50,9 @@ target_read_value.tar_builder <- function(target, pipeline = NULL) {
 
 #' @export
 target_prepare.tar_builder <- function(target, pipeline, scheduler, meta) {
-  target_patternview_started(target, pipeline, scheduler)
-  scheduler$progress$register_started(target)
-  scheduler$reporter$report_started(target, scheduler$progress)
+  target_patternview_dispatched(target, pipeline, scheduler)
+  scheduler$progress$register_dispatched(target)
+  scheduler$reporter$report_dispatched(target, scheduler$progress)
   builder_ensure_deps(target, pipeline, "main")
   builder_update_subpipeline(target, pipeline)
   builder_marshal_subpipeline(target)
@@ -193,19 +193,19 @@ target_conclude.tar_builder <- function(target, pipeline, scheduler, meta) {
     metrics_outcome(target$metrics),
     cancel = builder_cancel(target, pipeline, scheduler, meta),
     error = builder_error(target, pipeline, scheduler, meta),
-    built = builder_built(target, pipeline, scheduler, meta)
+    completed = builder_completed(target, pipeline, scheduler, meta)
   )
   NextMethod()
 }
 
-builder_built <- function(target, pipeline, scheduler, meta) {
+builder_completed <- function(target, pipeline, scheduler, meta) {
   store_cache_path(target$store, target$store$file$path)
   target_ensure_buds(target, pipeline, scheduler)
   meta$insert_record(target_produce_record(target, pipeline, meta))
   target_patternview_meta(target, pipeline, meta)
   pipeline_register_loaded(pipeline, target_get_name(target))
-  scheduler$progress$register_built(target)
-  scheduler$reporter$report_built(target, scheduler$progress)
+  scheduler$progress$register_completed(target)
+  scheduler$reporter$report_completed(target, scheduler$progress)
 }
 
 builder_error <- function(target, pipeline, scheduler, meta) {

R/class_inspection.R

@@ -159,15 +159,17 @@ inspection_class <- R6::R6Class(
         target_get_type(pipeline_get_target(pipeline, name))
       })
       progress <- self$progress$database$read_condensed_data()
-      # Keep this line for legacy reasons:
-      progress$progress <- gsub("running", "started", x = progress$progress)
+      # Keep these gsub lines for legacy reasons:
+      progress$progress <- gsub("running", "dispatched", x = progress$progress)
+      progress$progress <- gsub("started", "dispatched", x = progress$progress)
+      progress$progress <- gsub("built", "completed", x = progress$progress)
       if (self$outdated) {
-        index <- !(progress$progress %in% c("skipped", "built"))
+        index <- !(progress$progress %in% c("skipped", "completed"))
         progress <- progress[index,, drop = FALSE] # nolint
       }
       out <- merge(vertices, progress, all.x = TRUE, sort = FALSE)
       out <- out[order(out$name),, drop = FALSE] # nolint
-      levels <- c("skipped", "started", "built", "canceled", "errored")
+      levels <- c("skipped", "dispatched", "completed", "canceled", "errored")
       in_levels <- !is.na(out$progress) & out$progress %in% levels
       status <- ifelse(in_levels, out$progress, status)
       status[is.na(status)] <- "queued"

R/class_metrics.R

@@ -35,7 +35,7 @@ metrics_outcome <- function(metrics) {
   if_any(
     metrics_has_cancel(metrics),
     "cancel",
-    if_any(metrics_has_error(metrics), "error", "built")
+    if_any(metrics_has_error(metrics), "error", "completed")
   )
 }
 

R/class_pattern.R

@@ -270,8 +270,8 @@ pattern_conclude_final <- function(target, pipeline, scheduler, meta) {
   pattern_begin_final(target, pipeline, scheduler, meta)
   pattern_record_meta(target, pipeline, meta)
   patternview_register_final(target$patternview, target, scheduler)
-  if (identical(target$patternview$progress, "built")) {
-    scheduler$reporter$report_built(target, scheduler$progress)
+  if (identical(target$patternview$progress, "completed")) {
+    scheduler$reporter$report_completed(target, scheduler$progress)
   } else if (identical(target$patternview$progress, "skipped")) {
     scheduler$reporter$report_skipped(target, scheduler$progress)
   }

R/class_patternview.R

@@ -23,10 +23,10 @@ patternview_register_bytes <- function(patternview, record) {
   patternview$bytes <- patternview$bytes + record$bytes
 }
 
-patternview_register_started <- function(patternview, target, scheduler) {
+patternview_register_dispatched <- function(patternview, target, scheduler) {
   if (identical(patternview$progress, "queued")) {
-    patternview$progress <- "started"
-    scheduler$progress$buffer_started(target)
+    patternview$progress <- "dispatched"
+    scheduler$progress$buffer_dispatched(target)
   }
 }
 
@@ -45,9 +45,9 @@ patternview_register_errored <- function(patternview, target, scheduler) {
 }
 
 patternview_register_final <- function(patternview, target, scheduler) {
-  if (identical(patternview$progress, "started")) {
-    patternview$progress <- "built"
-    scheduler$progress$buffer_built(target)
+  if (identical(patternview$progress, "dispatched")) {
+    patternview$progress <- "completed"
+    scheduler$progress$buffer_completed(target)
   } else if (identical(patternview$progress, "queued")) {
     patternview$progress <- "skipped"
     scheduler$progress$buffer_skipped(target)
@@ -58,6 +58,6 @@ patternview_validate <- function(patternview) {
   tar_assert_correct_fields(patternview, patternview_new)
   tar_assert_in(
     patternview$progress,
-    c("queued", "started", "built", "canceled", "errored")
+    c("queued", "dispatched", "completed", "canceled", "errored")
   )
 }

R/class_progress.R

@@ -1,8 +1,8 @@
 progress_init <- function(
   path_store = path_store_default(),
   queued = counter_init(),
-  started = counter_init(),
-  built = counter_init(),
+  dispatched = counter_init(),
+  completed = counter_init(),
   skipped = counter_init(),
   errored = counter_init(),
   warned = counter_init(),
@@ -12,8 +12,8 @@ progress_init <- function(
   progress_new(
     database = database,
     queued = queued,
-    started = started,
-    built = built,
+    dispatched = dispatched,
+    completed = completed,
     skipped = skipped,
     errored = errored,
     warned = warned,
@@ -24,19 +24,19 @@ progress_init <- function(
 progress_new <- function(
   database = NULL,
   queued = NULL,
-  started = NULL,
+  dispatched = NULL,
   skipped = NULL,
-  built = NULL,
+  completed = NULL,
   errored = NULL,
   warned = NULL,
   canceled = NULL
 ) {
   progress_class$new(
     database = database,
     queued = queued,
-    started = started,
+    dispatched = dispatched,
     skipped = skipped,
-    built = built,
+    completed = completed,
     errored = errored,
     warned = warned,
     canceled = canceled
@@ -51,27 +51,27 @@ progress_class <- R6::R6Class(
   public = list(
     database = NULL,
     queued = NULL,
-    started = NULL,
+    dispatched = NULL,
     skipped = NULL,
-    built = NULL,
+    completed = NULL,
     errored = NULL,
     warned = NULL,
     canceled = NULL,
     initialize = function(
       database = NULL,
       queued = NULL,
-      started = NULL,
+      dispatched = NULL,
       skipped = NULL,
-      built = NULL,
+      completed = NULL,
       errored = NULL,
       warned = NULL,
       canceled = NULL
     ) {
       self$database <- database
       self$queued <- queued
-      self$started <- started
+      self$dispatched <- dispatched
       self$skipped <- skipped
-      self$built <- built
+      self$completed <- completed
       self$errored <- errored
       self$warned <- warned
       self$canceled <- canceled
@@ -87,30 +87,30 @@ progress_class <- R6::R6Class(
       counter_del_name(self$queued, name)
       counter_set_name(self$skipped, name)
     },
-    assign_started = function(target) {
+    assign_dispatched = function(target) {
       name <- target_get_name(target)
       counter_del_name(self$queued, name)
-      counter_set_name(self$started, name)
+      counter_set_name(self$dispatched, name)
     },
-    assign_built = function(target) {
+    assign_completed = function(target) {
       name <- target_get_name(target)
       counter_del_name(self$queued, name)
-      counter_del_name(self$started, name)
-      counter_set_name(self$built, name)
+      counter_del_name(self$dispatched, name)
+      counter_set_name(self$completed, name)
     },
     assign_canceled = function(target) {
       name <- target_get_name(target)
-      counter_del_name(self$started, name)
+      counter_del_name(self$dispatched, name)
       counter_set_name(self$canceled, name)
     },
     assign_errored = function(target) {
       name <- target_get_name(target)
-      counter_del_name(self$started, name)
+      counter_del_name(self$dispatched, name)
       counter_set_name(self$errored, name)
     },
     assign_warned = function(target) {
       name <- target_get_name(target)
-      counter_del_name(self$started, name)
+      counter_del_name(self$dispatched, name)
       counter_set_name(self$warned, name)
     },
     produce_row = function(target, progress) {
@@ -135,11 +135,11 @@ progress_class <- R6::R6Class(
     buffer_skipped = function(target) {
       self$buffer_progress(target, progress = "skipped")
     },
-    buffer_started = function(target) {
-      self$buffer_progress(target, progress = "started")
+    buffer_dispatched = function(target) {
+      self$buffer_progress(target, progress = "dispatched")
     },
-    buffer_built = function(target) {
-      self$buffer_progress(target, progress = "built")
+    buffer_completed = function(target) {
+      self$buffer_progress(target, progress = "completed")
     },
     buffer_errored = function(target) {
       self$buffer_progress(target, progress = "errored")
@@ -151,13 +151,13 @@ progress_class <- R6::R6Class(
       self$assign_skipped(target)
       self$buffer_skipped(target)
     },
-    register_started = function(target) {
-      self$assign_started(target)
-      self$buffer_started(target)
+    register_dispatched = function(target) {
+      self$assign_dispatched(target)
+      self$buffer_dispatched(target)
     },
-    register_built = function(target) {
-      self$assign_built(target)
-      self$buffer_built(target)
+    register_completed = function(target) {
+      self$assign_completed(target)
+      self$buffer_completed(target)
     },
     register_errored = function(target) {
       self$assign_errored(target)
@@ -169,7 +169,7 @@ progress_class <- R6::R6Class(
     },
     uptodate = function() {
       self$skipped$count > 0L &&
-        self$built$count == 0L &&
+        self$completed$count == 0L &&
         self$errored$count == 0L &&
         self$canceled$count == 0L
     },
@@ -188,12 +188,12 @@ progress_class <- R6::R6Class(
       )
     },
     any_remaining = function() {
-      self$queued$count > 0L || self$started$count > 0L
+      self$queued$count > 0L || self$dispatched$count > 0L
     },
     any_targets = function() {
-      count <- self$started$count +
+      count <- self$dispatched$count +
         self$skipped$count +
-        self$built$count +
+        self$completed$count +
         self$errored$count +
         self$warned$count +
         self$canceled$count
@@ -203,8 +203,8 @@ progress_class <- R6::R6Class(
       list(
         queue = self$queued$count,
         skip = self$skipped$count,
-        start = self$started$count,
-        built = self$built$count,
+        start = self$dispatched$count,
+        completed = self$completed$count,
         error = self$errored$count,
         warn = self$warned$count,
         cancel = self$canceled$count,
@@ -216,8 +216,8 @@ progress_class <- R6::R6Class(
     },
     validate = function() {
       counter_validate(self$queued)
-      counter_validate(self$started)
-      counter_validate(self$built)
+      counter_validate(self$dispatched)
+      counter_validate(self$completed)
       counter_validate(self$skipped)
       counter_validate(self$errored)
       counter_validate(self$canceled)

R/class_reporter.R

@@ -53,9 +53,9 @@ reporter_class <- R6::R6Class(
         cli_warned(progress$warned$count)
       }
     },
-    report_started = function(target = NULL, progress = NULL) {
+    report_dispatched = function(target = NULL, progress = NULL) {
     },
-    report_built = function(target = NULL, progress = NULL) {
+    report_completed = function(target = NULL, progress = NULL) {
     },
     report_skipped = function(target = NULL, progress = NULL) {
     },

R/class_scheduler.R

@@ -87,11 +87,11 @@ scheduler_class <- R6::R6Class(
         self$progress$queued,
         deps
       )
-      deps_started <- counter_filter_exists(
-        self$progress$started,
+      deps_dispatched <- counter_filter_exists(
+        self$progress$dispatched,
         deps
       )
-      length(deps_queued) + length(deps_started)
+      length(deps_queued) + length(deps_dispatched)
     },
     abridge = function(target) {
       self$reporter$report_error(target$metrics$error)

R/class_summary.R

@@ -24,10 +24,10 @@ summary_class <- R6::R6Class(
     },
     report_error = function(error) {
     },
-    report_started = function(target = NULL, progress) {
+    report_dispatched = function(target = NULL, progress) {
       self$report_progress(progress)
     },
-    report_built = function(target = NULL, progress) {
+    report_completed = function(target = NULL, progress) {
       self$report_progress(progress)
     },
     report_skipped = function(target = NULL, progress) {