promisor-remote: parse remote.*.partialclonefilter

diff --git a/progress.c b/progress.c
index 949a2a576d41be2a96c5fba1452b7472fea0510e..a2e8cf64a8d1aa2f94c745bbb5098b9c771f3a05 100644 (file)
--- a/progress.c
+++ b/progress.c
@@ -8,11 +8,12 @@
  * published by the Free Software Foundation.
  */
 
-#include "git-compat-util.h"
+#include "cache.h"
 #include "gettext.h"
 #include "progress.h"
 #include "strbuf.h"
 #include "trace.h"
+#include "utf8.h"
 
 #define TP_IDX_MAX      8
 
@@ -34,9 +35,12 @@ struct progress {
        uint64_t total;
        unsigned last_percent;
        unsigned delay;
+       unsigned sparse;
        struct throughput *throughput;
        uint64_t start_ns;
        struct strbuf counters_sb;
+       int title_len;
+       int split;
 };
 
 static volatile sig_atomic_t progress_update;
@@ -115,8 +119,24 @@ static void display(struct progress *progress, uint64_t n, const char *done)
                        size_t clear_len = counters_sb->len < last_count_len ?
                                        last_count_len - counters_sb->len + 1 :
                                        0;
-                       fprintf(stderr, "%s: %s%*s", progress->title,
-                               counters_sb->buf, (int) clear_len, eol);
+                       size_t progress_line_len = progress->title_len +
+                                               counters_sb->len + 2;
+                       int cols = term_columns();
+
+                       if (progress->split) {
+                               fprintf(stderr, "  %s%*s", counters_sb->buf,
+                                       (int) clear_len, eol);
+                       } else if (!done && cols < progress_line_len) {
+                               clear_len = progress->title_len + 1 < cols ?
+                                           cols - progress->title_len - 1 : 0;
+                               fprintf(stderr, "%s:%*s\n  %s%s",
+                                       progress->title, (int) clear_len, "",
+                                       counters_sb->buf, eol);
+                               progress->split = 1;
+                       } else {
+                               fprintf(stderr, "%s: %s%*s", progress->title,
+                                       counters_sb->buf, (int) clear_len, eol);
+                       }
                        fflush(stderr);
                }
                progress_update = 0;
@@ -147,12 +167,10 @@ void display_throughput(struct progress *progress, uint64_t total)
        now_ns = getnanotime();
 
        if (!tp) {
-               progress->throughput = tp = calloc(1, sizeof(*tp));
-               if (tp) {
-                       tp->prev_total = tp->curr_total = total;
-                       tp->prev_ns = now_ns;
-                       strbuf_init(&tp->display, 0);
-               }
+               progress->throughput = tp = xcalloc(1, sizeof(*tp));
+               tp->prev_total = tp->curr_total = total;
+               tp->prev_ns = now_ns;
+               strbuf_init(&tp->display, 0);
                return;
        }
        tp->curr_total = total;
@@ -203,39 +221,66 @@ void display_progress(struct progress *progress, uint64_t n)
 }
 
 static struct progress *start_progress_delay(const char *title, uint64_t total,
-                                            unsigned delay)
+                                            unsigned delay, unsigned sparse)
 {
-       struct progress *progress = malloc(sizeof(*progress));
-       if (!progress) {
-               /* unlikely, but here's a good fallback */
-               fprintf(stderr, "%s...\n", title);
-               fflush(stderr);
-               return NULL;
-       }
+       struct progress *progress = xmalloc(sizeof(*progress));
        progress->title = title;
        progress->total = total;
        progress->last_value = -1;
        progress->last_percent = -1;
        progress->delay = delay;
+       progress->sparse = sparse;
        progress->throughput = NULL;
        progress->start_ns = getnanotime();
        strbuf_init(&progress->counters_sb, 0);
+       progress->title_len = utf8_strwidth(title);
+       progress->split = 0;
        set_progress_signal();
        return progress;
 }
 
 struct progress *start_delayed_progress(const char *title, uint64_t total)
 {
-       return start_progress_delay(title, total, 2);
+       return start_progress_delay(title, total, 2, 0);
 }
 
 struct progress *start_progress(const char *title, uint64_t total)
 {
-       return start_progress_delay(title, total, 0);
+       return start_progress_delay(title, total, 0, 0);
+}
+
+/*
+ * Here "sparse" means that the caller might use some sampling criteria to
+ * decide when to call display_progress() rather than calling it for every
+ * integer value in[0 .. total).  In particular, the caller might not call
+ * display_progress() for the last value in the range.
+ *
+ * When "sparse" is set, stop_progress() will automatically force the done
+ * message to show 100%.
+ */
+struct progress *start_sparse_progress(const char *title, uint64_t total)
+{
+       return start_progress_delay(title, total, 0, 1);
+}
+
+struct progress *start_delayed_sparse_progress(const char *title,
+                                              uint64_t total)
+{
+       return start_progress_delay(title, total, 2, 1);
+}
+
+static void finish_if_sparse(struct progress *progress)
+{
+       if (progress &&
+           progress->sparse &&
+           progress->last_value != progress->total)
+               display_progress(progress, progress->total);
 }
 
 void stop_progress(struct progress **p_progress)
 {
+       finish_if_sparse(*p_progress);
+
        stop_progress_msg(p_progress, _("done"));
 }