refactor: WIP

Author: dieppa

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/ExecuteResponseData.java

@@ -34,9 +34,11 @@ public class ExecuteResponseData {
 
     // Aggregate counts
     private int totalStages;
+    private int reachedStages;
     private int completedStages;
     private int failedStages;
     private int totalChanges;
+    private int reachedChanges;
     private int appliedChanges;
     private int skippedChanges;
     private int failedChanges;
@@ -54,9 +56,11 @@ private ExecuteResponseData(Builder builder) {
         this.endTime = builder.endTime;
         this.totalDurationMs = builder.totalDurationMs;
         this.totalStages = builder.totalStages;
+        this.reachedStages = builder.reachedStages;
         this.completedStages = builder.completedStages;
         this.failedStages = builder.failedStages;
         this.totalChanges = builder.totalChanges;
+        this.reachedChanges = builder.reachedChanges;
         this.appliedChanges = builder.appliedChanges;
         this.skippedChanges = builder.skippedChanges;
         this.failedChanges = builder.failedChanges;
@@ -103,6 +107,14 @@ public void setTotalStages(int totalStages) {
         this.totalStages = totalStages;
     }
 
+    public int getReachedStages() {
+        return reachedStages;
+    }
+
+    public void setReachedStages(int reachedStages) {
+        this.reachedStages = reachedStages;
+    }
+
     public int getCompletedStages() {
         return completedStages;
     }
@@ -127,6 +139,14 @@ public void setTotalChanges(int totalChanges) {
         this.totalChanges = totalChanges;
     }
 
+    public int getReachedChanges() {
+        return reachedChanges;
+    }
+
+    public void setReachedChanges(int reachedChanges) {
+        this.reachedChanges = reachedChanges;
+    }
+
     public int getAppliedChanges() {
         return appliedChanges;
     }
@@ -177,9 +197,11 @@ public static class Builder {
         private Instant endTime;
         private long totalDurationMs;
         private int totalStages;
+        private int reachedStages;
         private int completedStages;
         private int failedStages;
         private int totalChanges;
+        private int reachedChanges;
         private int appliedChanges;
         private int skippedChanges;
         private int failedChanges;
@@ -210,6 +232,11 @@ public Builder totalStages(int totalStages) {
             return this;
         }
 
+        public Builder reachedStages(int reachedStages) {
+            this.reachedStages = reachedStages;
+            return this;
+        }
+
         public Builder completedStages(int completedStages) {
             this.completedStages = completedStages;
             return this;
@@ -225,6 +252,11 @@ public Builder totalChanges(int totalChanges) {
             return this;
         }
 
+        public Builder reachedChanges(int reachedChanges) {
+            this.reachedChanges = reachedChanges;
+            return this;
+        }
+
         public Builder appliedChanges(int appliedChanges) {
             this.appliedChanges = appliedChanges;
             return this;

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/ExecutionReportFormatter.java

@@ -61,6 +61,11 @@ public static String summary(ExecuteResponseData result) {
                     result.getFailedStages(),
                     result.getTotalStages(),
                     String.join(", ", failedStageNames));
+        } else if (result.getStatus() == ExecutionStatus.NO_CHANGES) {
+            return String.format(
+                    "Flamingock execution: no changes — %d stage(s) already up to date; duration=%dms",
+                    result.getTotalStages(),
+                    result.getTotalDurationMs());
         } else {
             headline = String.format(
                     "Flamingock execution completed: %d stage(s)",
@@ -98,25 +103,48 @@ public static String report(ExecuteResponseData result) {
 
         sb.append(" Stages:    ")
           .append(result.getTotalStages()).append(" total — ")
+          .append(result.getReachedStages()).append(" reached, ")
           .append(result.getCompletedStages()).append(" completed, ")
           .append(result.getFailedStages()).append(" failed")
           .append(NEWLINE);
         sb.append(" Changes:   ")
           .append(result.getTotalChanges()).append(" total — ")
+          .append(result.getReachedChanges()).append(" reached, ")
           .append(result.getAppliedChanges()).append(" applied, ")
           .append(result.getSkippedChanges()).append(" skipped, ")
           .append(result.getFailedChanges()).append(" failed")
           .append(NEWLINE);
 
+        // Per-stage breakdown: only stages the executor actually opened. Stages the planner
+        // short-circuited past are surfaced separately in the "Not reached" section below (when
+        // the coverage is partial — a fully up-to-date run shows neither, the headline carries it).
         List<StageResult> stages = nonNullStages(result);
-        if (!stages.isEmpty()) {
+        List<StageResult> reached = stages.stream()
+                .filter(StageResult::isWasExecuted)
+                .collect(Collectors.toList());
+        if (!reached.isEmpty()) {
             sb.append(NEWLINE).append(" Per-stage breakdown:").append(NEWLINE).append(NEWLINE);
-            for (StageResult stage : stages) {
+            for (StageResult stage : reached) {
                 appendStageBlock(sb, stage);
                 sb.append(NEWLINE);
             }
         }
 
+        // "Not reached" only appears when there's a partial: some stages ran, some didn't. The
+        // all-up-to-date case (0 reached) is communicated by the NO_CHANGES headline alone.
+        List<StageResult> notReached = stages.stream()
+                .filter(s -> !s.isWasExecuted())
+                .collect(Collectors.toList());
+        if (!notReached.isEmpty() && result.getReachedStages() > 0) {
+            sb.append(NEWLINE).append(" Not reached (").append(notReached.size()).append("):").append(NEWLINE);
+            for (StageResult stage : notReached) {
+                String name = stage.getStageName() != null ? stage.getStageName() : "(unnamed)";
+                sb.append("   - ").append(name)
+                  .append(" (").append(stage.getTotalChanges()).append(" changes)").append(NEWLINE);
+            }
+            sb.append(NEWLINE);
+        }
+
         sb.append(LINE);
         return sb.toString();
     }
@@ -208,7 +236,9 @@ private static String statusLabel(ExecuteResponseData result) {
         if (status == null) {
             return "UNKNOWN";
         }
-        return status.name();
+        // Render the enum name with underscores replaced by spaces so the headline reads naturally
+        // ("NO CHANGES" rather than "NO_CHANGES").
+        return status.name().replace('_', ' ');
     }
 
     private static boolean isFailedStatus(ExecutionStatus status) {

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/StageResult.java

@@ -29,6 +29,21 @@ public class StageResult {
     private long durationMs;
     private List<ChangeResult> changes;
 
+    /**
+     * True if the executor was invoked on this stage during the run. False for stages the planner
+     * short-circuited past (e.g. nothing to do per audit, or skipped because an earlier block
+     * aborted). Drives the reporter's "reached" vs "total" split — see {@code ExecutionReportFormatter}.
+     */
+    private boolean wasExecuted;
+
+    /**
+     * Structural change count from the loaded pipeline — total changes declared on this stage,
+     * regardless of how many were actually evaluated this run. Populated by
+     * {@code PipelineRun.toResponse()} for every stage so the reporter can render
+     * "Not reached" rows with accurate "(N changes)" counts even when {@link #changes} is empty.
+     */
+    private int totalChanges;
+
     public StageResult() {
         this.changes = new ArrayList<>();
         this.state = StageState.NOT_STARTED;
@@ -40,6 +55,8 @@ private StageResult(Builder builder) {
         this.state = builder.state != null ? builder.state : StageState.NOT_STARTED;
         this.durationMs = builder.durationMs;
         this.changes = builder.changes != null ? builder.changes : new ArrayList<>();
+        this.wasExecuted = builder.wasExecuted;
+        this.totalChanges = builder.totalChanges;
     }
 
     public String getStageId() {
@@ -82,6 +99,22 @@ public void setChanges(List<ChangeResult> changes) {
         this.changes = changes;
     }
 
+    public boolean isWasExecuted() {
+        return wasExecuted;
+    }
+
+    public void setWasExecuted(boolean wasExecuted) {
+        this.wasExecuted = wasExecuted;
+    }
+
+    public int getTotalChanges() {
+        return totalChanges;
+    }
+
+    public void setTotalChanges(int totalChanges) {
+        this.totalChanges = totalChanges;
+    }
+
     public boolean isFailed() {
         return state.isFailed();
     }
@@ -122,7 +155,9 @@ public static Builder builder(StageResult source) {
                 .stageName(source.stageName)
                 .state(source.state)
                 .durationMs(source.durationMs)
-                .changes(new ArrayList<>(source.changes));
+                .changes(new ArrayList<>(source.changes))
+                .wasExecuted(source.wasExecuted)
+                .totalChanges(source.totalChanges);
     }
 
     public static class Builder {
@@ -131,6 +166,8 @@ public static class Builder {
         private StageState state;
         private long durationMs;
         private List<ChangeResult> changes = new ArrayList<>();
+        private boolean wasExecuted;
+        private int totalChanges;
 
         public Builder stageId(String stageId) {
             this.stageId = stageId;
@@ -165,6 +202,16 @@ public Builder addChange(ChangeResult change) {
             return this;
         }
 
+        public Builder wasExecuted(boolean wasExecuted) {
+            this.wasExecuted = wasExecuted;
+            return this;
+        }
+
+        public Builder totalChanges(int totalChanges) {
+            this.totalChanges = totalChanges;
+            return this;
+        }
+
         public StageResult build() {
             return new StageResult(this);
         }