Commit 739601bf052c1ec247e9325da80e71425f910da8 - golang-github-vbauerster-mpb

+41

-0

.github/workflows/golangci-lint.yml less more

	0	name: golangci-lint
	1
	2	on:
	3	push:
	4	tags:
	5	- v*
	6	branches:
	7	- master
	8	- main
	9	pull_request:
	10
	11	permissions:
	12	contents: read
	13	# Optional: allow read access to pull request. Use with `only-new-issues` option.
	14	pull-requests: read
	15
	16	jobs:
	17	golangci:
	18	strategy:
	19	matrix:
	20	go-version: ['stable']
	21	os: [ubuntu-latest, macos-latest]
	22	runs-on: ${{ matrix.os }}
	23	steps:
	24	- uses: actions/checkout@v3
	25	- uses: actions/setup-go@v4
	26	with:
	27	go-version: ${{ matrix.go-version }}
	28	cache: false
	29	- uses: golangci/golangci-lint-action@v3
	30	with:
	31	# Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
	32	version: latest
	33	# Optional: working directory, useful for monorepos
	34	# working-directory: somedir
	35
	36	# Optional: golangci-lint command line arguments.
	37	# args: --issues-exit-code=0
	38
	39	# Optional: show only new issues if it's a pull request. The default value is `false`.
	40	only-new-issues: true

+28

-0

.github/workflows/test.yml less more

	0	name: test
	1
	2	on:
	3	push:
	4	tags:
	5	- v*
	6	branches:
	7	- master
	8	- v*
	9	pull_request:
	10
	11	permissions:
	12	contents: read
	13	pull-requests: read
	14
	15	jobs:
	16	test:
	17	strategy:
	18	matrix:
	19	go-version: ['stable', 'oldstable']
	20	os: [ubuntu-latest, macos-latest, windows-latest]
	21	runs-on: ${{ matrix.os }}
	22	steps:
	23	- uses: actions/checkout@v3
	24	- uses: actions/setup-go@v4
	25	with:
	26	go-version: ${{ matrix.go-version }}
	27	- run: go test -race ./...

+0

-11

~~.travis.yml~~ less more

0		language: go
1		arch:
2		- amd64
3		- ppc64le
4
5		go:
6		- 1.14.x
7
8		script:
9		- go test -race ./...
10		- for i in _examples//; do go build $i/.go \|\| exit 1; done

+15

-0

CONTRIBUTING less more

	0	When contributing your first changes, please include an empty commit for
	1	copyright waiver using the following message (replace 'John Doe' with
	2	your name or nickname):
	3
	4	John Doe Copyright Waiver
	5
	6	I dedicate any and all copyright interest in this software to the
	7	public domain. I make this dedication for the benefit of the public at
	8	large and to the detriment of my heirs and successors. I intend this
	9	dedication to be an overt act of relinquishment in perpetuity of all
	10	present and future rights to this software under copyright law.
	11
	12	The command to create an empty commit from the command-line is:
	13
	14	git commit --allow-empty

+15

-17

README.md less more

0	0	# Multi Progress Bar
1	1
2		[![GoDoc](https://pkg.go.dev/badge/github.com/vbauerster/mpb)](https://pkg.go.dev/github.com/vbauerster/mpb/v7)
3		[![Build Status](https://travis-ci.org/vbauerster/mpb.svg?branch=master)](https://travis-ci.org/vbauerster/mpb)
4		[![Go Report Card](https://goreportcard.com/badge/github.com/vbauerster/mpb)](https://goreportcard.com/report/github.com/vbauerster/mpb)
5		[![Donate with PayPal](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/vbauerster)
	2	[![GoDoc](https://pkg.go.dev/badge/github.com/vbauerster/mpb)](https://pkg.go.dev/github.com/vbauerster/mpb/v8)
	3	[![Test status](https://github.com/vbauerster/mpb/actions/workflows/test.yml/badge.svg)](https://github.com/vbauerster/mpb/actions/workflows/test.yml)
	4	[![Lint status](https://github.com/vbauerster/mpb/actions/workflows/golangci-lint.yml/badge.svg)](https://github.com/vbauerster/mpb/actions/workflows/golangci-lint.yml)
6	5
7	6	mpb is a Go lib for rendering progress bars in terminal applications.
8	7

26	25	"math/rand"
27	26	"time"
28	27
29		"github.com/vbauerster/mpb/v7"
30		"github.com/vbauerster/mpb/v7/decor"
	28	"github.com/vbauerster/mpb/v8"
	29	"github.com/vbauerster/mpb/v8/decor"
31	30	)
32	31
33	32	func main() {

36	35
37	36	total := 100
38	37	name := "Single Bar:"
39		// adding a single bar, which will inherit container's width
40		bar := p.Add(int64(total),
41		// progress bar filler with customized style
42		mpb.NewBarFiller(mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟")),
	38	// create a single bar, which will inherit container's width
	39	bar := p.New(int64(total),
	40	// BarFillerBuilder with custom style
	41	mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟"),
43	42	mpb.PrependDecorators(
44	43	// display our name with one space on the right
45	44	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),

65	64
66	65	```go
67	66	var wg sync.WaitGroup
68		// passed &wg will be accounted at p.Wait() call
	67	// passed wg will be accounted at p.Wait() call
69	68	p := mpb.New(mpb.WithWaitGroup(&wg))
70	69	total, numBars := 100, 3
71	70	wg.Add(numBars)

82	81	mpb.AppendDecorators(
83	82	// replace ETA decorator with "done" message, OnComplete event
84	83	decor.OnComplete(
85		// ETA decorator with ewma age of 60
86		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	84	// ETA decorator with ewma age of 30
	85	decor.EwmaETA(decor.ET_STYLE_GO, 30, decor.WCSyncWidth), "done",
87	86	),
88	87	),
89	88	)

97	96	// EWMA's unit of measure is an iteration's duration
98	97	start := time.Now()
99	98	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
100		bar.Increment()
101		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
102		bar.DecoratorEwmaUpdate(time.Since(start))
	99	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	100	bar.EwmaIncrement(time.Since(start))
103	101	}
104	102	}()
105	103	}
106		// Waiting for passed &wg and for all bars to complete and flush
	104	// wait for passed wg and for all bars to complete and flush
107	105	p.Wait()
108	106	```
109	107

+10

-2

_examples/barExtender/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/barExtender
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+13

-11

_examples/barExtender/main.go less more

6	6	"sync"
7	7	"time"
8	8
9		"github.com/vbauerster/mpb/v7"
10		"github.com/vbauerster/mpb/v7/decor"
	9	"github.com/vbauerster/mpb/v8"
	10	"github.com/vbauerster/mpb/v8/decor"
11	11	)
12	12
13	13	func main() {
14	14	var wg sync.WaitGroup
	15	// passed wg will be accounted at p.Wait() call
15	16	p := mpb.New(mpb.WithWaitGroup(&wg))
16	17	total, numBars := 100, 3
17	18	wg.Add(numBars)
18	19
19	20	for i := 0; i < numBars; i++ {
20	21	name := fmt.Sprintf("Bar#%d:", i)
21		efn := func(w io.Writer, _ int, s decor.Statistics) {
	22	efn := func(w io.Writer, s decor.Statistics) (err error) {
22	23	if s.Completed {
23		fmt.Fprintf(w, "Bar id: %d has been completed\n", s.ID)
	24	_, err = fmt.Fprintf(w, "Bar id: %d has been completed\n", s.ID)
24	25	}
	26	return err
25	27	}
26		bar := p.AddBar(int64(total), mpb.BarExtender(mpb.BarFillerFunc(efn)),
	28	bar := p.AddBar(int64(total),
	29	mpb.BarExtender(mpb.BarFillerFunc(efn), false),
27	30	mpb.PrependDecorators(
28	31	// simple name decorator
29	32	decor.Name(name),

33	36	mpb.AppendDecorators(
34	37	// replace ETA decorator with "done" message, OnComplete event
35	38	decor.OnComplete(
36		// ETA decorator with ewma age of 60
37		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	39	// ETA decorator with ewma age of 30
	40	decor.EwmaETA(decor.ET_STYLE_GO, 30), "done",
38	41	),
39	42	),
40	43	)

48	51	// EWMA's unit of measure is an iteration's duration
49	52	start := time.Now()
50	53	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
51		bar.Increment()
52		// since EWMA based decorator is used, DecoratorEwmaUpdate should be called
53		bar.DecoratorEwmaUpdate(time.Since(start))
	54	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	55	bar.EwmaIncrement(time.Since(start))
54	56	}
55	57	}()
56	58	}
57		// wait for all bars to complete and flush
	59	// wait for passed wg and for all bars to complete and flush
58	60	p.Wait()
59	61	}

+13

-0

_examples/barExtenderRev/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/barExtenderRev
	1
	2	go 1.17
	3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+137

-0

_examples/barExtenderRev/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math/rand"
	6	"sync/atomic"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v8"
	10	"github.com/vbauerster/mpb/v8/decor"
	11	)
	12
	13	var curTask uint32
	14	var doneTasks uint32
	15
	16	type task struct {
	17	id uint32
	18	total int64
	19	bar *mpb.Bar
	20	}
	21
	22	func main() {
	23	numTasks := 4
	24
	25	var total int64
	26	var filler mpb.BarFiller
	27	tasks := make([]*task, numTasks)
	28
	29	for i := 0; i < numTasks; i++ {
	30	task := &task{
	31	id: uint32(i),
	32	total: rand.Int63n(666) + 100,
	33	}
	34	total += task.total
	35	filler = middleware(filler, task.id)
	36	tasks[i] = task
	37	}
	38
	39	filler = newLineMiddleware(filler)
	40
	41	p := mpb.New()
	42
	43	for i := 0; i < numTasks; i++ {
	44	bar := p.AddBar(tasks[i].total,
	45	mpb.BarExtender(filler, true), // all bars share same extender filler
	46	mpb.BarFuncOptional(func() mpb.BarOption {
	47	return mpb.BarQueueAfter(tasks[i-1].bar)
	48	}, i != 0),
	49	mpb.PrependDecorators(
	50	decor.Name("current:", decor.WCSyncWidthR),
	51	),
	52	mpb.AppendDecorators(
	53	decor.Percentage(decor.WCSyncWidth),
	54	),
	55	)
	56	tasks[i].bar = bar
	57	}
	58
	59	tb := p.AddBar(0,
	60	mpb.PrependDecorators(
	61	decor.Any(func(st decor.Statistics) string {
	62	return fmt.Sprintf("TOTAL(%d/%d)", atomic.LoadUint32(&doneTasks), len(tasks))
	63	}, decor.WCSyncWidthR),
	64	),
	65	mpb.AppendDecorators(
	66	decor.Percentage(decor.WCSyncWidth),
	67	),
	68	)
	69
	70	tb.SetTotal(total, false)
	71
	72	for _, t := range tasks {
	73	atomic.StoreUint32(&curTask, t.id)
	74	complete(t.bar, tb)
	75	atomic.AddUint32(&doneTasks, 1)
	76	}
	77
	78	tb.EnableTriggerComplete()
	79
	80	p.Wait()
	81	}
	82
	83	func middleware(base mpb.BarFiller, id uint32) mpb.BarFiller {
	84	var done bool
	85	fn := func(w io.Writer, st decor.Statistics) error {
	86	if !done {
	87	if atomic.LoadUint32(&curTask) != id {
	88	_, err := fmt.Fprintf(w, " Taksk %02d\n", id)
	89	return err
	90	}
	91	if !st.Completed {
	92	_, err := fmt.Fprintf(w, "=> Taksk %02d\n", id)
	93	return err
	94	}
	95	done = true
	96	}
	97	_, err := fmt.Fprintf(w, " Taksk %02d: Done!\n", id)
	98	return err
	99	}
	100	if base == nil {
	101	return mpb.BarFillerFunc(fn)
	102	}
	103	return mpb.BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
	104	err := fn(w, st)
	105	if err != nil {
	106	return err
	107	}
	108	return base.Fill(w, st)
	109	})
	110	}
	111
	112	func newLineMiddleware(base mpb.BarFiller) mpb.BarFiller {
	113	return mpb.BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
	114	_, err := fmt.Fprintln(w)
	115	if err != nil {
	116	return err
	117	}
	118	return base.Fill(w, st)
	119	})
	120	}
	121
	122	func complete(bar, totalBar *mpb.Bar) {
	123	max := 100 * time.Millisecond
	124	for !bar.Completed() {
	125	n := rand.Int63n(10) + 1
	126	incrementBars(n, bar, totalBar)
	127	time.Sleep(time.Duration(n) * max / 10)
	128	}
	129	bar.Wait()
	130	}
	131
	132	func incrementBars(n int64, bb ...*mpb.Bar) {
	133	for _, b := range bb {
	134	b.IncrInt64(n)
	135	}
	136	}

+10

-2

_examples/cancel/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/cancel
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+10

-10

_examples/cancel/main.go less more

6	6	"sync"
7	7	"time"
8	8
9		"github.com/vbauerster/mpb/v7"
10		"github.com/vbauerster/mpb/v7/decor"
	9	"github.com/vbauerster/mpb/v8"
	10	"github.com/vbauerster/mpb/v8/decor"
11	11	)
12	12
13	13	func main() {

15	15	defer cancel()
16	16
17	17	var wg sync.WaitGroup
	18	// passed wg will be accounted at p.Wait() call
18	19	p := mpb.NewWithContext(ctx, mpb.WithWaitGroup(&wg))
19	20	total := 300
20	21	numBars := 3
21	22	wg.Add(numBars)
22	23
23	24	for i := 0; i < numBars; i++ {
24		name := fmt.Sprintf("Bar#%d:", i)
	25	name := fmt.Sprintf("Bar#%02d: ", i)
25	26	bar := p.AddBar(int64(total),
26	27	mpb.PrependDecorators(
27		decor.Name(name),
28		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	28	decor.Name(name, decor.WCSyncWidthR),
	29	decor.EwmaETA(decor.ET_STYLE_GO, 30, decor.WCSyncWidth),
29	30	),
30	31	mpb.AppendDecorators(
31	32	// note that OnComplete will not be fired, because of cancel

37	38	defer wg.Done()
38	39	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
39	40	max := 100 * time.Millisecond
40		for !bar.Completed() {
	41	for bar.IsRunning() {
41	42	// start variable is solely for EWMA calculation
42	43	// EWMA's unit of measure is an iteration's duration
43	44	start := time.Now()
44	45	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
45		bar.Increment()
46		// since EWMA based decorator is used, DecoratorEwmaUpdate should be called
47		bar.DecoratorEwmaUpdate(time.Since(start))
	46	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	47	bar.EwmaIncrement(time.Since(start))
48	48	}
49	49	}()
50	50	}
51
	51	// wait for passed wg and for all bars to complete and flush
52	52	p.Wait()
53	53	}

+15

-2

_examples/complex/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/complex
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require (
	5	github.com/fatih/color v1.15.0
	6	github.com/vbauerster/mpb/v8 v8.6.1
	7	)
	8
	9	require (
	10	github.com/VividCortex/ewma v1.2.0 // indirect
	11	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	12	github.com/mattn/go-colorable v0.1.13 // indirect
	13	github.com/mattn/go-isatty v0.0.19 // indirect
	14	github.com/mattn/go-runewidth v0.0.15 // indirect
	15	github.com/rivo/uniseg v0.4.4 // indirect
	16	golang.org/x/sys v0.11.0 // indirect
	17	)

+47

-49

_examples/complex/main.go less more

2	2	import (
3	3	"fmt"
4	4	"math/rand"
5		"sync"
6	5	"time"
7	6
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	7	"github.com/fatih/color"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
	12	func main() {
	13	numBars := 4
	14	// to support color in Windows following both options are required
	15	p := mpb.New(
	16	mpb.WithOutput(color.Output),
	17	mpb.WithAutoRefresh(),
	18	)
15	19
16		func main() {
17		doneWg := new(sync.WaitGroup)
18		p := mpb.New(mpb.WithWaitGroup(doneWg))
19		numBars := 4
	20	red, green := color.New(color.FgRed), color.New(color.FgGreen)
20	21
21		var bars []*mpb.Bar
22		var downloadWgg []*sync.WaitGroup
23	22	for i := 0; i < numBars; i++ {
24		wg := new(sync.WaitGroup)
25		wg.Add(1)
26		downloadWgg = append(downloadWgg, wg)
27	23	task := fmt.Sprintf("Task#%02d:", i)
28		job := "downloading"
29		b := p.AddBar(rand.Int63n(201)+100,
	24	queue := make([]*mpb.Bar, 2)
	25	queue[0] = p.AddBar(rand.Int63n(201)+100,
30	26	mpb.PrependDecorators(
31	27	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
32		decor.Name(job, decor.WCSyncSpaceR),
	28	decor.Name("downloading", decor.WCSyncSpaceR),
33	29	decor.CountersNoUnit("%d / %d", decor.WCSyncWidth),
34	30	),
35		mpb.AppendDecorators(decor.Percentage(decor.WC{W: 5})),
	31	mpb.AppendDecorators(
	32	decor.OnComplete(decor.Percentage(decor.WC{W: 5}), "done"),
	33	),
36	34	)
37		go newTask(wg, b, i+1)
38		bars = append(bars, b)
39		}
	35	queue[1] = p.AddBar(rand.Int63n(101)+100,
	36	mpb.BarQueueAfter(queue[0]), // this bar is queued
	37	mpb.BarFillerClearOnComplete(),
	38	mpb.PrependDecorators(
	39	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
	40	decor.OnCompleteMeta(
	41	decor.OnComplete(
	42	decor.Meta(decor.Name("installing", decor.WCSyncSpaceR), toMetaFunc(red)),
	43	"done!",
	44	),
	45	toMetaFunc(green),
	46	),
	47	decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_MMSS, 0, decor.WCSyncWidth), ""),
	48	),
	49	mpb.AppendDecorators(
	50	decor.OnComplete(decor.Percentage(decor.WC{W: 5}), ""),
	51	),
	52	)
40	53
41		for i := 0; i < numBars; i++ {
42		doneWg.Add(1)
43		i := i
44	54	go func() {
45		task := fmt.Sprintf("Task#%02d:", i)
46		// ANSI escape sequences are not supported on Windows OS
47		job := "\x1b[31;1;4mつのだ☆HIRO\x1b[0m"
48		// preparing delayed bars
49		b := p.AddBar(rand.Int63n(101)+100,
50		mpb.BarQueueAfter(bars[i]),
51		mpb.BarFillerClearOnComplete(),
52		mpb.PrependDecorators(
53		decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
54		decor.OnComplete(decor.Name(job, decor.WCSyncSpaceR), "done!"),
55		decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_MMSS, 0, decor.WCSyncWidth), ""),
56		),
57		mpb.AppendDecorators(
58		decor.OnComplete(decor.Percentage(decor.WC{W: 5}), ""),
59		),
60		)
61		// waiting for download to complete, before starting install job
62		downloadWgg[i].Wait()
63		go newTask(doneWg, b, numBars-i)
	55	for _, b := range queue {
	56	complete(b)
	57	}
64	58	}()
65	59	}
66	60
67	61	p.Wait()
68	62	}
69	63
70		func newTask(wg sync.WaitGroup, bar mpb.Bar, incrBy int) {
71		defer wg.Done()
	64	func complete(bar *mpb.Bar) {
72	65	max := 100 * time.Millisecond
73	66	for !bar.Completed() {
74	67	// start variable is solely for EWMA calculation
75	68	// EWMA's unit of measure is an iteration's duration
76	69	start := time.Now()
77	70	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
78		bar.IncrBy(incrBy)
79		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
80		bar.DecoratorEwmaUpdate(time.Since(start))
	71	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	72	bar.EwmaIncrInt64(rand.Int63n(5)+1, time.Since(start))
81	73	}
82	74	}
	75
	76	func toMetaFunc(c *color.Color) func(string) string {
	77	return func(s string) string {
	78	return c.Sprint(s)
	79	}
	80	}

+10

-2

_examples/decoratorsOnTop/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/decoratorsOnTop
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+13

-8

_examples/decoratorsOnTop/main.go less more

4	4	"math/rand"
5	5	"time"
6	6
7		"github.com/vbauerster/mpb/v7"
8		"github.com/vbauerster/mpb/v7/decor"
	7	"github.com/vbauerster/mpb/v8"
	8	"github.com/vbauerster/mpb/v8/decor"
9	9	)
10	10
11	11	func main() {
12	12	p := mpb.New()
13	13
14	14	total := 100
15		bar := p.Add(int64(total), nil,
	15	bar := p.New(int64(total),
	16	mpb.NopStyle(), // make main bar style nop, so there are just decorators
	17	mpb.BarExtender(extended(mpb.BarStyle().Build()), false), // extend wtih normal bar on the next line
16	18	mpb.PrependDecorators(
17	19	decor.Name("Percentage: "),
18	20	decor.NewPercentage("%d"),

23	25	decor.AverageETA(decor.ET_STYLE_GO), "done",
24	26	),
25	27	),
26		mpb.BarExtender(nlBarFiller(mpb.NewBarFiller(mpb.BarStyle()))),
27	28	)
28	29	// simulating some work
29	30	max := 100 * time.Millisecond

35	36	p.Wait()
36	37	}
37	38
38		func nlBarFiller(filler mpb.BarFiller) mpb.BarFiller {
39		return mpb.BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
40		filler.Fill(w, reqWidth, st)
41		w.Write([]byte("\n"))
	39	func extended(base mpb.BarFiller) mpb.BarFiller {
	40	return mpb.BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
	41	err := base.Fill(w, st)
	42	if err != nil {
	43	return err
	44	}
	45	_, err = io.WriteString(w, "\n")
	46	return err
42	47	})
43	48	}

+10

-2

_examples/differentWidth/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/differentWidth
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+8

-9

_examples/differentWidth/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
	14	// passed wg will be accounted at p.Wait() call
14	15	p := mpb.New(
15	16	mpb.WithWaitGroup(&wg),
16		// container's width.
17	17	mpb.WithWidth(60),
18	18	)
19	19	total, numBars := 100, 3

33	33	mpb.AppendDecorators(
34	34	// replace ETA decorator with "done" message, OnComplete event
35	35	decor.OnComplete(
36		// ETA decorator with ewma age of 60
37		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	36	// ETA decorator with ewma age of 30
	37	decor.EwmaETA(decor.ET_STYLE_GO, 30), "done",
38	38	),
39	39	),
40	40	)

48	48	// EWMA's unit of measure is an iteration's duration
49	49	start := time.Now()
50	50	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
51		bar.Increment()
52		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
53		bar.DecoratorEwmaUpdate(time.Since(start))
	51	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	52	bar.EwmaIncrement(time.Since(start))
54	53	}
55	54	}()
56	55	}
57		// wait for all bars to complete and flush
	56	// wait for passed wg and for all bars to complete and flush
58	57	p.Wait()
59	58	}

+10

-2

_examples/dynTotal/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/dynTotal
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+9

-17

_examples/dynTotal/main.go less more

4	4	"math/rand"
5	5	"time"
6	6
7		"github.com/vbauerster/mpb/v7"
8		"github.com/vbauerster/mpb/v7/decor"
	7	"github.com/vbauerster/mpb/v8"
	8	"github.com/vbauerster/mpb/v8/decor"
9	9	)
10
11		func init() {
12		rand.Seed(time.Now().UnixNano())
13		}
14	10
15	11	func main() {
16	12	p := mpb.New(mpb.WithWidth(64))
17	13
18		var total int64
19	14	// new bar with 'trigger complete event' disabled, because total is zero
20		bar := p.AddBar(total,
21		mpb.PrependDecorators(decor.Counters(decor.UnitKiB, "% .1f / % .1f")),
	15	bar := p.AddBar(0,
	16	mpb.PrependDecorators(decor.Counters(decor.SizeB1024(0), "% .1f / % .1f")),
22	17	mpb.AppendDecorators(decor.Percentage()),
23	18	)
24	19

26	21	read := makeStream(200)
27	22	for {
28	23	n, err := read()
29		total += int64(n)
30	24	if err == io.EOF {
	25	// triggering complete event now
	26	bar.SetTotal(-1, true)
31	27	break
32	28	}
33		// while total is unknown,
34		// set it to a positive number which is greater than current total,
35		// to make sure no complete event is triggered by next IncrBy call.
36		bar.SetTotal(total+2048, false)
	29	// increment methods won't trigger complete event because bar was constructed with total = 0
37	30	bar.IncrBy(n)
	31	// following call is not required, it's called to show some progress instead of an empty bar
	32	bar.SetTotal(bar.Current()+2048, false)
38	33	time.Sleep(time.Duration(rand.Intn(10)+1) * maxSleep / 10)
39	34	}
40
41		// force bar complete event, note true flag
42		bar.SetTotal(total, true)
43	35
44	36	p.Wait()
45	37	}

+8

-0

_examples/gomodtidyall.sh less more

	0	#!/bin/sh
	1
	2	for d in *; do
	3	[ ! -d "$d" ] && continue
	4	pushd "$d" >/dev/null 2>&1
	5	go mod tidy
	6	popd >/dev/null 2>&1
	7	done

+10

-2

_examples/io/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/io
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+8

-8

_examples/io/main.go less more

5	5	"io/ioutil"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {

18	18	mpb.WithRefreshRate(180*time.Millisecond),
19	19	)
20	20
21		bar := p.Add(total,
22		mpb.NewBarFiller(mpb.BarStyle().Rbound("\|")),
	21	bar := p.New(total,
	22	mpb.BarStyle().Rbound("\|"),
23	23	mpb.PrependDecorators(
24		decor.CountersKibiByte("% .2f / % .2f"),
	24	decor.Counters(decor.SizeB1024(0), "% .2f / % .2f"),
25	25	),
26	26	mpb.AppendDecorators(
27		decor.EwmaETA(decor.ET_STYLE_GO, 90),
	27	decor.EwmaETA(decor.ET_STYLE_GO, 30),
28	28	decor.Name(" ] "),
29		decor.EwmaSpeed(decor.UnitKiB, "% .2f", 60),
	29	decor.EwmaSpeed(decor.SizeB1024(0), "% .2f", 30),
30	30	),
31	31	)
32	32

35	35	defer proxyReader.Close()
36	36
37	37	// copy from proxyReader, ignoring errors
38		io.Copy(ioutil.Discard, proxyReader)
	38	_, _ = io.Copy(ioutil.Discard, proxyReader)
39	39
40	40	p.Wait()
41	41	}

+0

-5

~~_examples/merge/go.mod~~ less more

0		module github.com/vbauerster/mpb/_examples/merge
1
2		go 1.14
3
4		require github.com/vbauerster/mpb/v7 v7.0.3

+0

-72

~~_examples/merge/main.go~~ less more

0		package main
1
2		import (
3		"math/rand"
4		"strings"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
10		)
11
12		func main() {
13		var wg sync.WaitGroup
14		// pass &wg (optional), so p will wait for it eventually
15		p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithWidth(60))
16		total, numBars := 100, 3
17		wg.Add(numBars)
18
19		for i := 0; i < numBars; i++ {
20		var pdecorators mpb.BarOption
21		if i == 0 {
22		pdecorators = mpb.PrependDecorators(
23		decor.Merge(
24		decor.OnComplete(
25		newVariadicSpinner(decor.WCSyncSpace),
26		"done",
27		),
28		decor.WCSyncSpace, // Placeholder
29		decor.WCSyncSpace, // Placeholder
30		),
31		)
32		} else {
33		pdecorators = mpb.PrependDecorators(
34		decor.CountersNoUnit("% .1d / % .1d", decor.WCSyncSpace),
35		decor.OnComplete(decor.Spinner(nil, decor.WCSyncSpace), "done"),
36		decor.OnComplete(decor.Spinner(nil, decor.WCSyncSpace), "done"),
37		)
38		}
39		bar := p.AddBar(int64(total),
40		pdecorators,
41		mpb.AppendDecorators(
42		decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_GO, 60), "done"),
43		),
44		)
45		// simulating some work
46		go func() {
47		defer wg.Done()
48		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
49		max := 100 * time.Millisecond
50		for i := 0; i < total; i++ {
51		// start variable is solely for EWMA calculation
52		// EWMA's unit of measure is an iteration's duration
53		start := time.Now()
54		time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
55		bar.Increment()
56		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
57		bar.DecoratorEwmaUpdate(time.Since(start))
58		}
59		}()
60		}
61		// Waiting for passed &wg and for all bars to complete and flush
62		p.Wait()
63		}
64
65		func newVariadicSpinner(wc decor.WC) decor.Decorator {
66		spinner := decor.Spinner(nil)
67		fn := func(s decor.Statistics) string {
68		return strings.Repeat(spinner.Decor(s), int(s.Current/3))
69		}
70		return decor.Any(fn, wc)
71		}

+10

-2

_examples/mexicanBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/mexicanBar
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+19

-9

_examples/mexicanBar/main.go less more

3	3	"math/rand"
4	4	"time"
5	5
6		"github.com/vbauerster/mpb/v7"
7		"github.com/vbauerster/mpb/v7/decor"
	6	"github.com/vbauerster/mpb/v8"
	7	"github.com/vbauerster/mpb/v8/decor"
8	8	)
9	9
10	10	func main() {

14	14	total := 100
15	15	name := "Complex Filler:"
16	16	bs := mpb.BarStyle()
17		bs.Lbound("[\u001b[36;1m")
18		bs.Filler("_")
19		bs.Tip("\u001b[0m⛵\u001b[36;1m")
20		bs.Padding("_")
21		bs.Rbound("\u001b[0m]")
22		bar := p.Add(int64(total),
23		mpb.NewBarFiller(bs),
	17	bs = bs.LboundMeta(func(s string) string {
	18	return "\033[34m" + s + "\033[0m" // blue
	19	})
	20	bs = bs.Filler("_").FillerMeta(func(s string) string {
	21	return "\033[36m" + s + "\033[0m" // cyan
	22	})
	23	bs = bs.Tip("⛵").TipMeta(func(s string) string {
	24	return "\033[31m" + s + "\033[0m" // red
	25	})
	26	bs = bs.TipOnComplete() // leave tip on complete
	27	bs = bs.Padding("_").PaddingMeta(func(s string) string {
	28	return "\033[36m" + s + "\033[0m" // cyan
	29	})
	30	bs = bs.RboundMeta(func(s string) string {
	31	return "\033[34m" + s + "\033[0m" // blue
	32	})
	33	bar := p.New(int64(total), bs,
24	34	mpb.PrependDecorators(decor.Name(name)),
25	35	mpb.AppendDecorators(decor.Percentage()),
26	36	)

+10

-2

_examples/multiBars/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/multiBars
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+8

-9

_examples/multiBars/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
14		// passed &wg will be accounted at p.Wait() call
	14	// passed wg will be accounted at p.Wait() call
15	15	p := mpb.New(mpb.WithWaitGroup(&wg))
16	16	total, numBars := 100, 3
17	17	wg.Add(numBars)

28	28	mpb.AppendDecorators(
29	29	// replace ETA decorator with "done" message, OnComplete event
30	30	decor.OnComplete(
31		// ETA decorator with ewma age of 60
32		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	31	// ETA decorator with ewma age of 30
	32	decor.EwmaETA(decor.ET_STYLE_GO, 30, decor.WCSyncWidth), "done",
33	33	),
34	34	),
35	35	)

43	43	// EWMA's unit of measure is an iteration's duration
44	44	start := time.Now()
45	45	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
46		bar.Increment()
47		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
48		bar.DecoratorEwmaUpdate(time.Since(start))
	46	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	47	bar.EwmaIncrement(time.Since(start))
49	48	}
50	49	}()
51	50	}
52		// Waiting for passed &wg and for all bars to complete and flush
	51	// wait for passed wg and for all bars to complete and flush
53	52	p.Wait()
54	53	}

+0

-5

~~_examples/panic/go.mod~~ less more

0		module github.com/vbauerster/mpb/_examples/panic
1
2		go 1.14
3
4		require github.com/vbauerster/mpb/v7 v7.0.3

+0

-45

~~_examples/panic/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"os"
5		"strings"
6		"sync"
7		"time"
8
9		"github.com/vbauerster/mpb/v7"
10		"github.com/vbauerster/mpb/v7/decor"
11		)
12
13		func main() {
14		var wg sync.WaitGroup
15		p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
16
17		wantPanic := strings.Repeat("Panic ", 64)
18		numBars := 3
19		wg.Add(numBars)
20
21		for i := 0; i < numBars; i++ {
22		name := fmt.Sprintf("b#%02d:", i)
23		bar := p.AddBar(100, mpb.BarID(i), mpb.PrependDecorators(panicDecorator(name, wantPanic)))
24
25		go func() {
26		defer wg.Done()
27		for i := 0; i < 100; i++ {
28		time.Sleep(50 * time.Millisecond)
29		bar.Increment()
30		}
31		}()
32		}
33
34		p.Wait()
35		}
36
37		func panicDecorator(name, panicMsg string) decor.Decorator {
38		return decor.Any(func(st decor.Statistics) string {
39		if st.ID == 1 && st.Current >= 42 {
40		panic(panicMsg)
41		}
42		return name
43		})
44		}

+10

-2

_examples/poplog/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/poplog
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+5

-7

_examples/poplog/main.go less more

4	4	"math/rand"
5	5	"time"
6	6
7		"github.com/vbauerster/mpb/v7"
8		"github.com/vbauerster/mpb/v7/decor"
	7	"github.com/vbauerster/mpb/v8"
	8	"github.com/vbauerster/mpb/v8/decor"
9	9	)
10	10
11	11	func main() {
	12	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
12	13	p := mpb.New(mpb.PopCompletedMode())
13
14	14	total, numBars := 100, 4
15	15	for i := 0; i < numBars; i++ {
16	16	name := fmt.Sprintf("Bar#%d:", i)

27	27	),
28	28	)
29	29	// simulating some work
30		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
31	30	max := 100 * time.Millisecond
32	31	for i := 0; i < total; i++ {
33	32	// start variable is solely for EWMA calculation
34	33	// EWMA's unit of measure is an iteration's duration
35	34	start := time.Now()
36	35	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
37		bar.Increment()
38		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
39		bar.DecoratorEwmaUpdate(time.Since(start))
	36	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	37	bar.EwmaIncrement(time.Since(start))
40	38	}
41	39	}
42	40

+13

-0

_examples/progressAsWriter/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/progressAsWriter
	1
	2	go 1.17
	3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+78

-0

_examples/progressAsWriter/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"log"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v8"
	10	"github.com/vbauerster/mpb/v8/decor"
	11	)
	12
	13	func main() {
	14	total, numBars := 100, 2
	15	var wg sync.WaitGroup
	16	wg.Add(numBars)
	17	done := make(chan interface{})
	18	p := mpb.New(
	19	mpb.WithWidth(64),
	20	mpb.WithWaitGroup(&wg),
	21	mpb.WithShutdownNotifier(done),
	22	)
	23
	24	log.SetOutput(p)
	25
	26	for i := 0; i < numBars; i++ {
	27	name := fmt.Sprintf("Bar#%d:", i)
	28	bar := p.AddBar(int64(total),
	29	mpb.PrependDecorators(
	30	decor.Name(name),
	31	decor.Percentage(decor.WCSyncSpace),
	32	),
	33	mpb.AppendDecorators(
	34	decor.OnComplete(
	35	decor.EwmaETA(decor.ET_STYLE_GO, 30, decor.WCSyncWidth), "done",
	36	),
	37	),
	38	)
	39	// simulating some work
	40	go func() {
	41	defer wg.Done()
	42	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	43	max := 100 * time.Millisecond
	44	for i := 0; i < total; i++ {
	45	// start variable is solely for EWMA calculation
	46	// EWMA's unit of measure is an iteration's duration
	47	start := time.Now()
	48	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	49	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	50	bar.EwmaIncrement(time.Since(start))
	51	}
	52	log.Println(name, "done")
	53	}()
	54	}
	55
	56	var qwg sync.WaitGroup
	57	qwg.Add(1)
	58	go func() {
	59	quit:
	60	for {
	61	select {
	62	case <-done:
	63	// after done, underlying io.Writer returns mpb.DoneError
	64	// so following isn't printed
	65	log.Println("all done")
	66	break quit
	67	default:
	68	log.Println("waiting for done")
	69	time.Sleep(100 * time.Millisecond)
	70	}
	71	}
	72	qwg.Done()
	73	}()
	74
	75	p.Wait()
	76	qwg.Wait()
	77	}

+10

-2

_examples/quietMode/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/quietMode
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+10

-17

_examples/quietMode/main.go less more

2	2	import (
3	3	"flag"
4	4	"fmt"
	5	"io"
5	6	"math/rand"
6	7	"sync"
7	8	"time"
8	9
9		"github.com/vbauerster/mpb/v7"
10		"github.com/vbauerster/mpb/v7/decor"
	10	"github.com/vbauerster/mpb/v8"
	11	"github.com/vbauerster/mpb/v8/decor"
11	12	)
12	13
13	14	var quietMode bool

19	20	func main() {
20	21	flag.Parse()
21	22	var wg sync.WaitGroup
22		// pass &wg (optional), so p will wait for it eventually
	23	// passed wg will be accounted at p.Wait() call
23	24	p := mpb.New(
24	25	mpb.WithWaitGroup(&wg),
25		mpb.ContainerOptional(
26		// setting to nil will:
27		// set output to ioutil.Discard and disable refresh rate cycle, in
28		// order not to consume much CPU. Hovewer a single refresh still will
29		// be triggered on bar complete event, per each bar.
30		mpb.WithOutput(nil),
31		quietMode,
32		),
	26	mpb.ContainerOptional(mpb.WithOutput(io.Discard), quietMode),
33	27	)
34	28	total, numBars := 100, 3
35	29	wg.Add(numBars)

46	40	mpb.AppendDecorators(
47	41	// replace ETA decorator with "done" message, OnComplete event
48	42	decor.OnComplete(
49		// ETA decorator with ewma age of 60
50		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	43	// ETA decorator with ewma age of 30
	44	decor.EwmaETA(decor.ET_STYLE_GO, 30), "done",
51	45	),
52	46	),
53	47	)

61	55	// EWMA's unit of measure is an iteration's duration
62	56	start := time.Now()
63	57	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
64		bar.Increment()
65		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
66		bar.DecoratorEwmaUpdate(time.Since(start))
	58	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	59	bar.EwmaIncrement(time.Since(start))
67	60	}
68	61	}()
69	62	}
70		// Waiting for passed &wg and for all bars to complete and flush
	63	// wait for passed wg and for all bars to complete and flush
71	64	p.Wait()
72	65	fmt.Println("done")
73	66	}

+10

-2

_examples/remove/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/remove
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+16

-13

_examples/remove/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
	14	// passed wg will be accounted at p.Wait() call
14	15	p := mpb.New(mpb.WithWaitGroup(&wg))
15	16	total := 100
16	17	numBars := 3

23	24	mpb.BarOptional(mpb.BarRemoveOnComplete(), i == 0),
24	25	mpb.PrependDecorators(
25	26	decor.Name(name),
26		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
27	27	),
28		mpb.AppendDecorators(decor.Percentage()),
	28	mpb.AppendDecorators(
	29	decor.Any(func(s decor.Statistics) string {
	30	return fmt.Sprintf("completed: %v", s.Completed)
	31	}, decor.WCSyncSpaceR),
	32	decor.Any(func(s decor.Statistics) string {
	33	return fmt.Sprintf("aborted: %v", s.Aborted)
	34	}, decor.WCSyncSpaceR),
	35	decor.OnComplete(decor.NewPercentage("%d", decor.WCSyncSpace), "done"),
	36	decor.OnAbort(decor.NewPercentage("%d", decor.WCSyncSpace), "ohno"),
	37	),
29	38	)
30	39	go func() {
31	40	defer wg.Done()
32	41	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
33	42	max := 100 * time.Millisecond
34		for i := 0; !bar.Completed(); i++ {
35		// start variable is solely for EWMA calculation
36		// EWMA's unit of measure is an iteration's duration
37		start := time.Now()
	43	for i := 0; bar.IsRunning(); i++ {
38	44	if bar.ID() == 2 && i >= 42 {
39		// aborting and removing while bar is running
40		bar.Abort(true)
	45	go bar.Abort(false)
41	46	}
42	47	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
43	48	bar.Increment()
44		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
45		bar.DecoratorEwmaUpdate(time.Since(start))
46	49	}
47	50	}()
48	51	}
49
	52	// wait for passed wg and for all bars to complete and flush
50	53	p.Wait()
51	54	}

+10

-2

_examples/reverseBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/reverseBar
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+17

-16

_examples/reverseBar/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
14		// pass &wg (optional), so p will wait for it eventually
	14	// passed wg will be accounted at p.Wait() call
15	15	p := mpb.New(mpb.WithWaitGroup(&wg))
16	16	total, numBars := 100, 3
17	17	wg.Add(numBars)
18	18
	19	condFillerBuilder := func(cond bool) mpb.BarFillerBuilder {
	20	if cond { // reverse Bar on cond
	21	return mpb.BarStyle().Tip("<").Reverse()
	22	}
	23	return mpb.BarStyle()
	24	}
	25
19	26	for i := 0; i < numBars; i++ {
20	27	name := fmt.Sprintf("Bar#%d:", i)
21		bs := mpb.BarStyle()
22		if i == 1 {
23		// reverse Bar#1
24		bs = bs.Tip("<").Reverse()
25		}
26		bar := p.Add(int64(total),
27		mpb.NewBarFiller(bs),
	28	bar := p.New(int64(total),
	29	condFillerBuilder(i == 1),
28	30	mpb.PrependDecorators(
29	31	// simple name decorator
30	32	decor.Name(name),

34	36	mpb.AppendDecorators(
35	37	// replace ETA decorator with "done" message, OnComplete event
36	38	decor.OnComplete(
37		// ETA decorator with ewma age of 60
38		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	39	// ETA decorator with ewma age of 30
	40	decor.EwmaETA(decor.ET_STYLE_GO, 30), "done",
39	41	),
40	42	),
41	43	)

49	51	// EWMA's unit of measure is an iteration's duration
50	52	start := time.Now()
51	53	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
52		bar.Increment()
53		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
54		bar.DecoratorEwmaUpdate(time.Since(start))
	54	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	55	bar.EwmaIncrement(time.Since(start))
55	56	}
56	57	}()
57	58	}
58		// Waiting for passed &wg and for all bars to complete and flush
	59	// wait for passed wg and for all bars to complete and flush
59	60	p.Wait()
60	61	}

+10

-2

_examples/singleBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/singleBar
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+6

-6

_examples/singleBar/main.go less more

3	3	"math/rand"
4	4	"time"
5	5
6		"github.com/vbauerster/mpb/v7"
7		"github.com/vbauerster/mpb/v7/decor"
	6	"github.com/vbauerster/mpb/v8"
	7	"github.com/vbauerster/mpb/v8/decor"
8	8	)
9	9
10	10	func main() {

13	13
14	14	total := 100
15	15	name := "Single Bar:"
16		// adding a single bar, which will inherit container's width
17		bar := p.Add(int64(total),
18		// progress bar filler with customized style
19		mpb.NewBarFiller(mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟")),
	16	// create a single bar, which will inherit container's width
	17	bar := p.New(int64(total),
	18	// BarFillerBuilder with custom style
	19	mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟"),
20	20	mpb.PrependDecorators(
21	21	// display our name with one space on the right
22	22	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),

+10

-2

_examples/spinTipBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/spinTipBar
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+6

-4

_examples/spinTipBar/main.go less more

3	3	"math/rand"
4	4	"time"
5	5
6		"github.com/vbauerster/mpb/v7"
7		"github.com/vbauerster/mpb/v7/decor"
	6	"github.com/vbauerster/mpb/v8"
	7	"github.com/vbauerster/mpb/v8/decor"
8	8	)
9	9
10	10	func main() {

13	13
14	14	total := 100
15	15	name := "Single Bar:"
16		bar := p.Add(int64(total),
17		mpb.NewBarFiller(mpb.BarStyle().Tip(`-`, `\`, `\|`, `/`)),
	16	bar := p.New(int64(total),
	17	mpb.BarStyle().Tip(`-`, `\`, `\|`, `/`).TipMeta(func(s string) string {
	18	return "\033[31m" + s + "\033[0m" // red
	19	}),
18	20	mpb.PrependDecorators(decor.Name(name)),
19	21	mpb.AppendDecorators(decor.Percentage()),
20	22	)

+10

-2

_examples/spinnerBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/spinnerBar
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+29

-40

_examples/spinnerBar/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
	14	// passed wg will be accounted at p.Wait() call
14	15	p := mpb.New(
15	16	mpb.WithWaitGroup(&wg),
16		mpb.WithWidth(14),
	17	mpb.WithWidth(16),
17	18	)
18	19	total, numBars := 101, 3
19	20	wg.Add(numBars)
20	21
21		spinnerStyle := []string{"∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"}
	22	condFillerBuilder := func(cond bool) mpb.BarFillerBuilder {
	23	if cond {
	24	s := mpb.SpinnerStyle("∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙")
	25	return s.Meta(func(s string) string {
	26	return "\033[31m" + s + "\033[0m" // red
	27	})
	28	}
	29	return mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟")
	30	}
22	31
23	32	for i := 0; i < numBars; i++ {
24	33	name := fmt.Sprintf("Bar#%d:", i)
25		var bar *mpb.Bar
26		if i == 0 {
27		bar = p.Add(int64(total),
28		mpb.NewBarFiller(mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟")),
29		mpb.PrependDecorators(
30		// simple name decorator
31		decor.Name(name),
	34	bar := p.New(int64(total),
	35	condFillerBuilder(i != 0),
	36	mpb.PrependDecorators(
	37	// simple name decorator
	38	decor.Name(name),
	39	),
	40	mpb.AppendDecorators(
	41	// replace ETA decorator with "done" message, OnComplete event
	42	decor.OnComplete(
	43	// ETA decorator with ewma age of 30
	44	decor.EwmaETA(decor.ET_STYLE_GO, 30), "done",
32	45	),
33		mpb.AppendDecorators(
34		// replace ETA decorator with "done" message, OnComplete event
35		decor.OnComplete(
36		// ETA decorator with ewma age of 60
37		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
38		),
39		),
40		)
41		} else {
42		bar = p.Add(int64(total),
43		mpb.NewBarFiller(mpb.SpinnerStyle(spinnerStyle...)),
44		mpb.PrependDecorators(
45		// simple name decorator
46		decor.Name(name),
47		),
48		mpb.AppendDecorators(
49		// replace ETA decorator with "done" message, OnComplete event
50		decor.OnComplete(
51		// ETA decorator with ewma age of 60
52		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
53		),
54		),
55		)
56		}
57
	46	),
	47	)
58	48	// simulating some work
59	49	go func() {
60	50	defer wg.Done()

65	55	// EWMA's unit of measure is an iteration's duration
66	56	start := time.Now()
67	57	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
68		bar.Increment()
69		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
70		bar.DecoratorEwmaUpdate(time.Since(start))
	58	// we need to call EwmaIncrement to fulfill ewma decorator's contract
	59	bar.EwmaIncrement(time.Since(start))
71	60	}
72	61	}()
73	62	}
74		// wait for all bars to complete and flush
	63	// wait for passed wg and for all bars to complete and flush
75	64	p.Wait()
76	65	}

+10

-2

_examples/spinnerDecorator/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/spinnerDecorator
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+4

-4

_examples/spinnerDecorator/main.go less more

5	5	"sync"
6	6	"time"
7	7
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
10	10	)
11	11
12	12	func main() {
13	13	var wg sync.WaitGroup
14		// pass &wg (optional), so p will wait for it eventually
	14	// passed wg will be accounted at p.Wait() call
15	15	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithWidth(64))
16	16	total, numBars := 100, 3
17	17	wg.Add(numBars)

43	43	}
44	44	}()
45	45	}
46		// Waiting for passed &wg and for all bars to complete and flush
	46	// wait for passed wg and for all bars to complete and flush
47	47	p.Wait()
48	48	}

+15

-2

_examples/stress/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/stress
1	1
2		go 1.14
	2	go 1.17
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require (
	5	github.com/pkg/profile v1.7.0
	6	github.com/vbauerster/mpb/v8 v8.6.1
	7	)
	8
	9	require (
	10	github.com/VividCortex/ewma v1.2.0 // indirect
	11	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	12	github.com/felixge/fgprof v0.9.3 // indirect
	13	github.com/google/pprof v0.0.0-20230821062121-407c9e7a662f // indirect
	14	github.com/mattn/go-runewidth v0.0.15 // indirect
	15	github.com/rivo/uniseg v0.4.4 // indirect
	16	golang.org/x/sys v0.11.0 // indirect
	17	)

+19

-9

_examples/stress/main.go less more

0	0	package main
1	1
2	2	import (
	3	"flag"
3	4	"fmt"
4	5	"math/rand"
	6	"os"
5	7	"sync"
6	8	"time"
7	9
8		"github.com/vbauerster/mpb/v7"
9		"github.com/vbauerster/mpb/v7/decor"
	10	"github.com/pkg/profile"
	11	"github.com/vbauerster/mpb/v8"
	12	"github.com/vbauerster/mpb/v8/decor"
10	13	)
11	14
12	15	const (
13	16	totalBars = 32
14	17	)
15	18
	19	var proftype = flag.String("prof", "", "profile type (cpu, mem)")
	20
16	21	func main() {
	22	flag.Parse()
	23	switch *proftype {
	24	case "cpu":
	25	defer profile.Start(profile.CPUProfile, profile.ProfilePath("."), profile.NoShutdownHook).Stop()
	26	case "mem":
	27	defer profile.Start(profile.MemProfile, profile.ProfilePath("."), profile.NoShutdownHook).Stop()
	28	}
17	29	var wg sync.WaitGroup
18		p := mpb.New(
19		mpb.WithWaitGroup(&wg),
20		mpb.WithRefreshRate(50*time.Millisecond),
21		)
	30	// passed wg will be accounted at p.Wait() call
	31	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
22	32	wg.Add(totalBars)
23	33
24	34	for i := 0; i < totalBars; i++ {

26	36	total := rand.Intn(320) + 10
27	37	bar := p.AddBar(int64(total),
28	38	mpb.PrependDecorators(
29		decor.Name(name),
30		decor.Elapsed(decor.ET_STYLE_GO, decor.WCSyncSpace),
	39	decor.Name(name, decor.WCSyncWidthR),
	40	decor.Elapsed(decor.ET_STYLE_GO, decor.WCSyncWidth),
31	41	),
32	42	mpb.AppendDecorators(
33	43	decor.OnComplete(

46	56	}
47	57	}()
48	58	}
49
	59	// wait for passed wg and for all bars to complete and flush
50	60	p.Wait()
51	61	}

+10

-3

_examples/suppressBar/go.mod less more

0	0	module github.com/vbauerster/mpb/_examples/suppressBar
1	1
2		go 1.14
	2	go 1.17
3	3
4	4	require (
5		github.com/mattn/go-runewidth v0.0.13
6		github.com/vbauerster/mpb/v7 v7.0.3
	5	github.com/mattn/go-runewidth v0.0.15
	6	github.com/vbauerster/mpb/v8 v8.6.1
7	7	)
	8
	9	require (
	10	github.com/VividCortex/ewma v1.2.0 // indirect
	11	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	12	github.com/rivo/uniseg v0.4.4 // indirect
	13	golang.org/x/sys v0.11.0 // indirect
	14	)

+46

-31

_examples/suppressBar/main.go less more

8	8	"time"
9	9
10	10	"github.com/mattn/go-runewidth"
11		"github.com/vbauerster/mpb/v7"
12		"github.com/vbauerster/mpb/v7/decor"
	11	"github.com/vbauerster/mpb/v8"
	12	"github.com/vbauerster/mpb/v8/decor"
13	13	)
14	14
15	15	func main() {

19	19	msgCh := make(chan string)
20	20	resumeCh := make(chan struct{})
21	21	nextCh := make(chan struct{}, 1)
	22	ew := &errorWrapper{}
	23	timer := time.AfterFunc(2*time.Second, func() {
	24	ew.reset(errors.New("timeout"))
	25	})
	26	defer timer.Stop()
22	27	bar := p.AddBar(int64(total),
23	28	mpb.BarFillerMiddleware(func(base mpb.BarFiller) mpb.BarFiller {
24	29	var msg *string
25		return mpb.BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
26		select {
27		case m := <-msgCh:
	30	var times int
	31	return mpb.BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
	32	if msg == nil {
	33	select {
	34	case m := <-msgCh:
	35	msg = &m
	36	times = 10
	37	nextCh <- struct{}{}
	38	default:
	39	}
	40	return base.Fill(w, st)
	41	}
	42	switch {
	43	case times == 0, st.Completed, st.Aborted:
28	44	defer func() {
29		msg = &m
	45	msg = nil
30	46	}()
31		nextCh <- struct{}{}
32		case <-resumeCh:
33		msg = nil
	47	resumeCh <- struct{}{}
34	48	default:
	49	times--
35	50	}
36		if msg != nil {
37		io.WriteString(w, runewidth.Truncate(*msg, st.AvailableWidth, "…"))
38		nextCh <- struct{}{}
39		} else {
40		base.Fill(w, reqWidth, st)
41		}
	51	_, err := io.WriteString(w, runewidth.Truncate(*msg, st.AvailableWidth, "…"))
	52	nextCh <- struct{}{}
	53	return err
42	54	})
43	55	}),
44	56	mpb.PrependDecorators(decor.Name("my bar:")),
45	57	mpb.AppendDecorators(newCustomPercentage(nextCh)),
46	58	)
47		ew := &errorWrapper{}
48		time.AfterFunc(2*time.Second, func() {
49		ew.reset(errors.New("timeout"))
50		})
51	59	// simulating some work
52	60	go func() {
53	61	rng := rand.New(rand.NewSource(time.Now().UnixNano()))

56	64	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
57	65	if ew.isErr() {
58	66	msgCh <- fmt.Sprintf("%s at %d, retrying...", ew.Error(), i)
59		go ew.reset(nil)
60	67	i--
61	68	bar.SetRefill(int64(i))
62		time.Sleep(3 * time.Second)
63		resumeCh <- struct{}{}
	69	ew.reset(nil)
	70	<-resumeCh
64	71	continue
65	72	}
66	73	bar.Increment()

93	100	ew.Unlock()
94	101	}
95	102
	103	type percentage struct {
	104	decor.Decorator
	105	suspend <-chan struct{}
	106	}
	107
	108	func (d percentage) Decor(s decor.Statistics) (string, int) {
	109	select {
	110	case <-d.suspend:
	111	return d.Format("")
	112	default:
	113	return d.Decorator.Decor(s)
	114	}
	115	}
	116
96	117	func newCustomPercentage(nextCh <-chan struct{}) decor.Decorator {
97		base := decor.Percentage()
98		fn := func(s decor.Statistics) string {
99		select {
100		case <-nextCh:
101		return ""
102		default:
103		return base.Decor(s)
104		}
	118	return percentage{
	119	Decorator: decor.Percentage(),
	120	suspend: nextCh,
105	121	}
106		return decor.Any(fn)
107	122	}

+13

-0

_examples/tipOnComplete/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/tipOnComplete
	1
	2	go 1.17
	3
	4	require github.com/vbauerster/mpb/v8 v8.6.1
	5
	6	require (
	7	github.com/VividCortex/ewma v1.2.0 // indirect
	8	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
	9	github.com/mattn/go-runewidth v0.0.15 // indirect
	10	github.com/rivo/uniseg v0.4.4 // indirect
	11	golang.org/x/sys v0.11.0 // indirect
	12	)

+30

-0

_examples/tipOnComplete/main.go less more

	0	package main
	1
	2	import (
	3	"math/rand"
	4	"time"
	5
	6	"github.com/vbauerster/mpb/v8"
	7	"github.com/vbauerster/mpb/v8/decor"
	8	)
	9
	10	func main() {
	11	// initialize progress container, with custom width
	12	p := mpb.New(mpb.WithWidth(80))
	13
	14	total := 100
	15	name := "Single Bar:"
	16	bar := p.New(int64(total),
	17	mpb.BarStyle().TipOnComplete(),
	18	mpb.PrependDecorators(decor.Name(name)),
	19	mpb.AppendDecorators(decor.Percentage()),
	20	)
	21	// simulating some work
	22	max := 100 * time.Millisecond
	23	for i := 0; i < total; i++ {
	24	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	25	bar.Increment()
	26	}
	27	// wait for our bar to complete and flush
	28	p.Wait()
	29	}

+493

-323

bar.go less more

2	2	import (
3	3	"bytes"
4	4	"context"
5		"fmt"
6	5	"io"
7		"log"
8		"runtime/debug"
9	6	"strings"
	7	"sync"
10	8	"time"
11	9
12	10	"github.com/acarl005/stripansi"
13	11	"github.com/mattn/go-runewidth"
14		"github.com/vbauerster/mpb/v7/decor"
	12	"github.com/vbauerster/mpb/v8/decor"
15	13	)
16	14
17	15	// Bar represents a progress bar.
18	16	type Bar struct {
19		priority int // used by heap
20		index int // used by heap
21
22		extendedLines int
23		toShutdown bool
24		toDrop bool
25		noPop bool
26		hasEwmaDecorators bool
27		operateState chan func(*bState)
28		frameCh chan io.Reader
29		syncTableCh chan [][]chan int
30		completed chan bool
31
32		// cancel is called either by user or on complete event
33		cancel func()
34		// done is closed after cacheState is assigned
35		done chan struct{}
36		// cacheState is populated, right after close(shutdown)
37		cacheState *bState
38
39		container *Progress
40		dlogger *log.Logger
41		recoveredPanic interface{}
42		}
43
44		type extenderFunc func(in io.Reader, reqWidth int, st decor.Statistics) (out io.Reader, lines int)
45
46		// bState is actual bar state. It gets passed to *Bar.serve(...) monitor
47		// goroutine.
	17	index int // used by heap
	18	priority int // used by heap
	19	frameCh chan *renderFrame
	20	operateState chan func(*bState)
	21	done chan struct{}
	22	container *Progress
	23	bs *bState
	24	cancel func()
	25	}
	26
	27	type syncTable [2][]chan int
	28	type extenderFunc func([]io.Reader, decor.Statistics) ([]io.Reader, error)
	29
	30	// bState is actual bar's state.
48	31	type bState struct {
49	32	id int
50	33	priority int
51	34	reqWidth int
	35	shutdown int
52	36	total int64
53	37	current int64
54	38	refill int64
55		lastN int64
56		iterated bool
57	39	trimSpace bool
58	40	completed bool
59		completeFlushed bool
	41	aborted bool
60	42	triggerComplete bool
61		dropOnComplete bool
	43	rmOnComplete bool
62	44	noPop bool
	45	autoRefresh bool
63	46	aDecorators []decor.Decorator
64	47	pDecorators []decor.Decorator
65	48	averageDecorators []decor.AverageDecorator
66	49	ewmaDecorators []decor.EwmaDecorator
67	50	shutdownListeners []decor.ShutdownListener
68		bufP, bufB, bufA *bytes.Buffer
	51	buffers [3]*bytes.Buffer
69	52	filler BarFiller
70		middleware func(BarFiller) BarFiller
71	53	extender extenderFunc
72
73		// runningBar is a key for *pState.parkedBars
74		runningBar *Bar
75
76		debugOut io.Writer
77		}
78
79		func newBar(container Progress, bs bState) *Bar {
80		logPrefix := fmt.Sprintf("%sbar#%02d ", container.dlogger.Prefix(), bs.id)
81		ctx, cancel := context.WithCancel(container.ctx)
	54	renderReq chan<- time.Time
	55	waitBar Bar // key for (pState).queueBars
	56	}
	57
	58	type renderFrame struct {
	59	rows []io.Reader
	60	shutdown int
	61	rmOnComplete bool
	62	noPop bool
	63	done bool
	64	err error
	65	}
	66
	67	func newBar(ctx context.Context, container Progress, bs bState) *Bar {
	68	ctx, cancel := context.WithCancel(ctx)
82	69
83	70	bar := &Bar{
	71	priority: bs.priority,
	72	frameCh: make(chan *renderFrame, 1),
	73	operateState: make(chan func(*bState)),
	74	done: make(chan struct{}),
84	75	container: container,
85		priority: bs.priority,
86		toDrop: bs.dropOnComplete,
87		noPop: bs.noPop,
88		operateState: make(chan func(*bState)),
89		frameCh: make(chan io.Reader, 1),
90		syncTableCh: make(chan [][]chan int, 1),
91		completed: make(chan bool, 1),
92		done: make(chan struct{}),
93	76	cancel: cancel,
94		dlogger: log.New(bs.debugOut, logPrefix, log.Lshortfile),
95		}
96
	77	}
	78
	79	container.bwg.Add(1)
97	80	go bar.serve(ctx, bs)
98	81	return bar
99	82	}
100	83
101		// ProxyReader wraps r with metrics required for progress tracking.
102		// Panics if r is nil.
	84	// ProxyReader wraps io.Reader with metrics required for progress tracking.
	85	// If `r` is 'unknown total/size' reader it's mandatory to call
	86	// (*Bar).SetTotal(-1, true) method after (io.Reader).Read returns io.EOF.
	87	// If bar is already completed or aborted, returns nil.
	88	// Panics if `r` is nil.
103	89	func (b *Bar) ProxyReader(r io.Reader) io.ReadCloser {
104	90	if r == nil {
105	91	panic("expected non nil io.Reader")
106	92	}
107		return newProxyReader(r, b)
	93	result := make(chan bool)
	94	select {
	95	case b.operateState <- func(s *bState) { result <- len(s.ewmaDecorators) != 0 }:
	96	return newProxyReader(r, b, <-result)
	97	case <-b.done:
	98	return nil
	99	}
	100	}
	101
	102	// ProxyWriter wraps io.Writer with metrics required for progress tracking.
	103	// If bar is already completed or aborted, returns nil.
	104	// Panics if `w` is nil.
	105	func (b *Bar) ProxyWriter(w io.Writer) io.WriteCloser {
	106	if w == nil {
	107	panic("expected non nil io.Writer")
	108	}
	109	result := make(chan bool)
	110	select {
	111	case b.operateState <- func(s *bState) { result <- len(s.ewmaDecorators) != 0 }:
	112	return newProxyWriter(w, b, <-result)
	113	case <-b.done:
	114	return nil
	115	}
108	116	}
109	117
110	118	// ID returs id of the bar.

114	122	case b.operateState <- func(s *bState) { result <- s.id }:
115	123	return <-result
116	124	case <-b.done:
117		return b.cacheState.id
118		}
119		}
120
121		// Current returns bar's current number, in other words sum of all increments.
	125	return b.bs.id
	126	}
	127	}
	128
	129	// Current returns bar's current value, in other words sum of all increments.
122	130	func (b *Bar) Current() int64 {
123	131	result := make(chan int64)
124	132	select {
125	133	case b.operateState <- func(s *bState) { result <- s.current }:
126	134	return <-result
127	135	case <-b.done:
128		return b.cacheState.current
	136	return b.bs.current
129	137	}
130	138	}
131	139

136	144	func (b *Bar) SetRefill(amount int64) {
137	145	select {
138	146	case b.operateState <- func(s *bState) {
139		s.refill = amount
	147	if amount < s.current {
	148	s.refill = amount
	149	} else {
	150	s.refill = s.current
	151	}
140	152	}:
141	153	case <-b.done:
142	154	}

144	156
145	157	// TraverseDecorators traverses all available decorators and calls cb func on each.
146	158	func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) {
147		select {
148		case b.operateState <- func(s *bState) {
149		for _, decorators := range [...][]decor.Decorator{
	159	iter := make(chan decor.Decorator)
	160	select {
	161	case b.operateState <- func(s *bState) {
	162	for _, decorators := range [][]decor.Decorator{
150	163	s.pDecorators,
151	164	s.aDecorators,
152	165	} {
153	166	for _, d := range decorators {
154		cb(extractBaseDecorator(d))
	167	iter <- d
155	168	}
156	169	}
157		}:
158		case <-b.done:
159		}
160		}
161
162		// SetTotal sets total dynamically.
163		// If total is less than or equal to zero it takes progress' current value.
164		func (b *Bar) SetTotal(total int64, triggerComplete bool) {
165		select {
166		case b.operateState <- func(s *bState) {
167		s.triggerComplete = triggerComplete
168		if total <= 0 {
	170	close(iter)
	171	}:
	172	for d := range iter {
	173	cb(unwrap(d))
	174	}
	175	case <-b.done:
	176	}
	177	}
	178
	179	// EnableTriggerComplete enables triggering complete event. It's
	180	// effective only for bars which were constructed with `total <= 0` and
	181	// after total has been set with (*Bar).SetTotal(int64, false). If bar
	182	// has been incremented to the total, complete event is triggered right
	183	// away.
	184	func (b *Bar) EnableTriggerComplete() {
	185	select {
	186	case b.operateState <- func(s *bState) {
	187	if s.triggerComplete \|\| s.total <= 0 {
	188	return
	189	}
	190	if s.current >= s.total {
	191	s.current = s.total
	192	s.completed = true
	193	b.triggerCompletion(s)
	194	} else {
	195	s.triggerComplete = true
	196	}
	197	}:
	198	case <-b.done:
	199	}
	200	}
	201
	202	// SetTotal sets total to an arbitrary value. It's effective only for
	203	// bar which was constructed with `total <= 0`. Setting total to negative
	204	// value is equivalent to (Bar).SetTotal((Bar).Current(), bool) but faster.
	205	// If triggerCompletion is true, total value is set to current and
	206	// complete event is triggered right away.
	207	func (b *Bar) SetTotal(total int64, triggerCompletion bool) {
	208	select {
	209	case b.operateState <- func(s *bState) {
	210	if s.triggerComplete {
	211	return
	212	}
	213	if total < 0 {
169	214	s.total = s.current
170	215	} else {
171	216	s.total = total
172	217	}
173		if s.triggerComplete && !s.completed {
	218	if triggerCompletion {
174	219	s.current = s.total
175	220	s.completed = true
176		go b.refreshTillShutdown()
	221	b.triggerCompletion(s)
177	222	}
178	223	}:
179	224	case <-b.done:

181	226	}
182	227
183	228	// SetCurrent sets progress' current to an arbitrary value.
184		// Setting a negative value will cause a panic.
185	229	func (b *Bar) SetCurrent(current int64) {
186		select {
187		case b.operateState <- func(s *bState) {
188		s.iterated = true
189		s.lastN = current - s.current
	230	if current < 0 {
	231	return
	232	}
	233	select {
	234	case b.operateState <- func(s *bState) {
190	235	s.current = current
191	236	if s.triggerComplete && s.current >= s.total {
192	237	s.current = s.total
193	238	s.completed = true
194		go b.refreshTillShutdown()
	239	b.triggerCompletion(s)
	240	}
	241	}:
	242	case <-b.done:
	243	}
	244	}
	245
	246	// EwmaSetCurrent sets progress' current to an arbitrary value and updates
	247	// EWMA based decorators by dur of a single iteration.
	248	func (b *Bar) EwmaSetCurrent(current int64, iterDur time.Duration) {
	249	if current < 0 {
	250	return
	251	}
	252	select {
	253	case b.operateState <- func(s *bState) {
	254	if n := current - s.current; n > 0 {
	255	s.decoratorEwmaUpdate(n, iterDur)
	256	}
	257	s.current = current
	258	if s.triggerComplete && s.current >= s.total {
	259	s.current = s.total
	260	s.completed = true
	261	b.triggerCompletion(s)
195	262	}
196	263	}:
197	264	case <-b.done:

210	277
211	278	// IncrInt64 increments progress by amount of n.
212	279	func (b *Bar) IncrInt64(n int64) {
213		select {
214		case b.operateState <- func(s *bState) {
215		s.iterated = true
216		s.lastN = n
	280	if n <= 0 {
	281	return
	282	}
	283	select {
	284	case b.operateState <- func(s *bState) {
217	285	s.current += n
218	286	if s.triggerComplete && s.current >= s.total {
219	287	s.current = s.total
220	288	s.completed = true
221		go b.refreshTillShutdown()
222		}
223		}:
224		case <-b.done:
225		}
226		}
227
228		// DecoratorEwmaUpdate updates all EWMA based decorators. Should be
229		// called on each iteration, because EWMA's unit of measure is an
230		// iteration's duration. Panics if called before *Bar.Incr... family
231		// methods.
232		func (b *Bar) DecoratorEwmaUpdate(dur time.Duration) {
233		select {
234		case b.operateState <- func(s *bState) {
235		ewmaIterationUpdate(false, s, dur)
236		}:
237		case <-b.done:
238		ewmaIterationUpdate(true, b.cacheState, dur)
	289	b.triggerCompletion(s)
	290	}
	291	}:
	292	case <-b.done:
	293	}
	294	}
	295
	296	// EwmaIncrement is a shorthand for b.EwmaIncrInt64(1, iterDur).
	297	func (b *Bar) EwmaIncrement(iterDur time.Duration) {
	298	b.EwmaIncrInt64(1, iterDur)
	299	}
	300
	301	// EwmaIncrBy is a shorthand for b.EwmaIncrInt64(int64(n), iterDur).
	302	func (b *Bar) EwmaIncrBy(n int, iterDur time.Duration) {
	303	b.EwmaIncrInt64(int64(n), iterDur)
	304	}
	305
	306	// EwmaIncrInt64 increments progress by amount of n and updates EWMA based
	307	// decorators by dur of a single iteration.
	308	func (b *Bar) EwmaIncrInt64(n int64, iterDur time.Duration) {
	309	if n <= 0 {
	310	return
	311	}
	312	select {
	313	case b.operateState <- func(s *bState) {
	314	s.decoratorEwmaUpdate(n, iterDur)
	315	s.current += n
	316	if s.triggerComplete && s.current >= s.total {
	317	s.current = s.total
	318	s.completed = true
	319	b.triggerCompletion(s)
	320	}
	321	}:
	322	case <-b.done:
239	323	}
240	324	}
241	325

244	328	// or after progress resume.
245	329	func (b *Bar) DecoratorAverageAdjust(start time.Time) {
246	330	select {
247		case b.operateState <- func(s *bState) {
248		for _, d := range s.averageDecorators {
249		d.AverageAdjust(start)
250		}
251		}:
	331	case b.operateState <- func(s *bState) { s.decoratorAverageAdjust(start) }:
252	332	case <-b.done:
253	333	}
254	334	}

257	337	// priority, i.e. bar will be on top. If you don't need to set priority
258	338	// dynamically, better use BarPriority option.
259	339	func (b *Bar) SetPriority(priority int) {
260		select {
261		case <-b.done:
262		default:
263		b.container.setBarPriority(b, priority)
264		}
265		}
266
267		// Abort interrupts bar's running goroutine. Call this, if you'd like
268		// to stop/remove bar before completion event. It has no effect after
269		// completion event. If drop is true bar will be removed as well.
	340	b.container.UpdateBarPriority(b, priority, false)
	341	}
	342
	343	// Abort interrupts bar's running goroutine. Abort won't be engaged
	344	// if bar is already in complete state. If drop is true bar will be
	345	// removed as well. To make sure that bar has been removed call
	346	// (*Bar).Wait method.
270	347	func (b *Bar) Abort(drop bool) {
271	348	select {
272		case <-b.done:
273		default:
274		if drop {
275		b.container.dropBar(b)
276		}
277		b.cancel()
	349	case b.operateState <- func(s *bState) {
	350	if s.completed \|\| s.aborted {
	351	return
	352	}
	353	s.aborted = true
	354	s.rmOnComplete = drop
	355	b.triggerCompletion(s)
	356	}:
	357	case <-b.done:
	358	}
	359	}
	360
	361	// Aborted reports whether the bar is in aborted state.
	362	func (b *Bar) Aborted() bool {
	363	result := make(chan bool)
	364	select {
	365	case b.operateState <- func(s *bState) { result <- s.aborted }:
	366	return <-result
	367	case <-b.done:
	368	return b.bs.aborted
278	369	}
279	370	}
280	371
281	372	// Completed reports whether the bar is in completed state.
282	373	func (b *Bar) Completed() bool {
283		select {
284		case b.operateState <- func(s *bState) { b.completed <- s.completed }:
285		return <-b.completed
286		case <-b.done:
287		return true
288		}
289		}
290
291		func (b Bar) serve(ctx context.Context, s bState) {
	374	result := make(chan bool)
	375	select {
	376	case b.operateState <- func(s *bState) { result <- s.completed }:
	377	return <-result
	378	case <-b.done:
	379	return b.bs.completed
	380	}
	381	}
	382
	383	// IsRunning reports whether the bar is running, i.e. not yet completed
	384	// and not yet aborted.
	385	func (b *Bar) IsRunning() bool {
	386	result := make(chan bool)
	387	select {
	388	case b.operateState <- func(s *bState) { result <- !s.completed && !s.aborted }:
	389	return <-result
	390	case <-b.done:
	391	return false
	392	}
	393	}
	394
	395	// Wait blocks until bar is completed or aborted.
	396	func (b *Bar) Wait() {
	397	<-b.done
	398	}
	399
	400	func (b Bar) serve(ctx context.Context, bs bState) {
292	401	defer b.container.bwg.Done()
293	402	for {
294	403	select {
295	404	case op := <-b.operateState:
296		op(s)
	405	op(bs)
297	406	case <-ctx.Done():
298		b.cacheState = s
	407	bs.aborted = !bs.completed
	408	bs.decoratorShutdownNotify()
	409	b.bs = bs
299	410	close(b.done)
300		// Notifying decorators about shutdown event
301		for _, sl := range s.shutdownListeners {
302		sl.Shutdown()
	411	return
	412	}
	413	}
	414	}
	415
	416	func (b *Bar) render(tw int) {
	417	var done bool
	418	fn := func(s *bState) {
	419	var rows []io.Reader
	420	stat := newStatistics(tw, s)
	421	r, err := s.draw(stat)
	422	if err != nil {
	423	b.frameCh <- &renderFrame{err: err}
	424	return
	425	}
	426	rows = append(rows, r)
	427	if s.extender != nil {
	428	rows, err = s.extender(rows, stat)
	429	if err != nil {
	430	b.frameCh <- &renderFrame{err: err}
	431	return
303	432	}
304		return
305		}
306		}
307		}
308
309		func (b *Bar) render(tw int) {
310		select {
311		case b.operateState <- func(s *bState) {
312		stat := newStatistics(tw, s)
313		defer func() {
314		// recovering if user defined decorator panics for example
315		if p := recover(); p != nil {
316		if b.recoveredPanic == nil {
317		s.extender = makePanicExtender(p)
318		b.toShutdown = !b.toShutdown
319		b.recoveredPanic = p
320		}
321		frame, lines := s.extender(nil, s.reqWidth, stat)
322		b.extendedLines = lines
323		b.frameCh <- frame
324		b.dlogger.Println(p)
	433	}
	434	frame := &renderFrame{
	435	rows: rows,
	436	shutdown: s.shutdown,
	437	rmOnComplete: s.rmOnComplete,
	438	noPop: s.noPop,
	439	done: done,
	440	}
	441	if s.completed \|\| s.aborted {
	442	// post increment makes sure OnComplete decorators are rendered
	443	s.shutdown++
	444	}
	445	b.frameCh <- frame
	446	}
	447	select {
	448	case b.operateState <- fn:
	449	case <-b.done:
	450	done = true
	451	fn(b.bs)
	452	}
	453	}
	454
	455	func (b Bar) triggerCompletion(s bState) {
	456	if s.autoRefresh {
	457	// Technically this call isn't required, but if refresh rate is set to
	458	// one hour for example and bar completes within a few minutes p.Wait()
	459	// will wait for one hour. This call helps to avoid unnecessary waiting.
	460	go b.tryEarlyRefresh(s.renderReq)
	461	} else {
	462	b.cancel()
	463	}
	464	}
	465
	466	func (b *Bar) tryEarlyRefresh(renderReq chan<- time.Time) {
	467	var anyOtherRunning bool
	468	b.container.traverseBars(func(bar *Bar) bool {
	469	anyOtherRunning = b != bar && bar.IsRunning()
	470	return anyOtherRunning
	471	})
	472	if !anyOtherRunning {
	473	for {
	474	select {
	475	case renderReq <- time.Now():
	476	case <-b.done:
	477	return
325	478	}
326		s.completeFlushed = s.completed
327		}()
328		frame, lines := s.extender(s.draw(stat), s.reqWidth, stat)
329		b.extendedLines = lines
330		b.toShutdown = s.completed && !s.completeFlushed
331		b.frameCh <- frame
332		}:
333		case <-b.done:
334		s := b.cacheState
335		stat := newStatistics(tw, s)
336		var r io.Reader
337		if b.recoveredPanic == nil {
338		r = s.draw(stat)
339		}
340		frame, lines := s.extender(r, s.reqWidth, stat)
341		b.extendedLines = lines
342		b.frameCh <- frame
343		}
344		}
345
346		func (b *Bar) subscribeDecorators() {
347		var averageDecorators []decor.AverageDecorator
348		var ewmaDecorators []decor.EwmaDecorator
349		var shutdownListeners []decor.ShutdownListener
350		b.TraverseDecorators(func(d decor.Decorator) {
351		if d, ok := d.(decor.AverageDecorator); ok {
352		averageDecorators = append(averageDecorators, d)
353		}
354		if d, ok := d.(decor.EwmaDecorator); ok {
355		ewmaDecorators = append(ewmaDecorators, d)
356		}
357		if d, ok := d.(decor.ShutdownListener); ok {
358		shutdownListeners = append(shutdownListeners, d)
359		}
360		})
361		select {
362		case b.operateState <- func(s *bState) {
363		s.averageDecorators = averageDecorators
364		s.ewmaDecorators = ewmaDecorators
365		s.shutdownListeners = shutdownListeners
366		}:
367		b.hasEwmaDecorators = len(ewmaDecorators) != 0
368		case <-b.done:
369		}
370		}
371
372		func (b *Bar) refreshTillShutdown() {
373		for {
374		select {
375		case b.container.refreshCh <- time.Now():
376		case <-b.done:
377		return
378		}
379		}
380		}
381
382		func (b *Bar) wSyncTable() [][]chan int {
383		select {
384		case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
385		return <-b.syncTableCh
386		case <-b.done:
387		return b.cacheState.wSyncTable()
388		}
389		}
390
391		func (s *bState) draw(stat decor.Statistics) io.Reader {
392		nlr := strings.NewReader("\n")
393		tw := stat.AvailableWidth
394		for _, d := range s.pDecorators {
395		str := d.Decor(stat)
396		stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
397		s.bufP.WriteString(str)
398		}
399		if stat.AvailableWidth < 1 {
400		trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufP.String()), tw, "…"))
401		s.bufP.Reset()
402		return io.MultiReader(trunc, nlr)
403		}
404
405		if !s.trimSpace && stat.AvailableWidth > 1 {
	479	}
	480	}
	481	}
	482
	483	func (b *Bar) wSyncTable() syncTable {
	484	result := make(chan syncTable)
	485	select {
	486	case b.operateState <- func(s *bState) { result <- s.wSyncTable() }:
	487	return <-result
	488	case <-b.done:
	489	return b.bs.wSyncTable()
	490	}
	491	}
	492
	493	func (s *bState) draw(stat decor.Statistics) (io.Reader, error) {
	494	r, err := s.drawImpl(stat)
	495	if err != nil {
	496	for _, b := range s.buffers {
	497	b.Reset()
	498	}
	499	return nil, err
	500	}
	501	return io.MultiReader(r, strings.NewReader("\n")), nil
	502	}
	503
	504	func (s *bState) drawImpl(stat decor.Statistics) (io.Reader, error) {
	505	decorFiller := func(buf *bytes.Buffer, decorators []decor.Decorator) (err error) {
	506	for _, d := range decorators {
	507	// need to call Decor in any case becase of width synchronization
	508	str, width := d.Decor(stat)
	509	if err != nil {
	510	continue
	511	}
	512	if w := stat.AvailableWidth - width; w >= 0 {
	513	_, err = buf.WriteString(str)
	514	stat.AvailableWidth = w
	515	} else if stat.AvailableWidth > 0 {
	516	trunc := runewidth.Truncate(stripansi.Strip(str), stat.AvailableWidth, "…")
	517	_, err = buf.WriteString(trunc)
	518	stat.AvailableWidth = 0
	519	}
	520	}
	521	return err
	522	}
	523
	524	bufP, bufB, bufA := s.buffers[0], s.buffers[1], s.buffers[2]
	525
	526	err := eitherError(decorFiller(bufP, s.pDecorators), decorFiller(bufA, s.aDecorators))
	527	if err != nil {
	528	return nil, err
	529	}
	530
	531	if !s.trimSpace && stat.AvailableWidth >= 2 {
406	532	stat.AvailableWidth -= 2
407		s.bufB.WriteByte(' ')
408		defer s.bufB.WriteByte(' ')
409		}
410
411		tw = stat.AvailableWidth
412		for _, d := range s.aDecorators {
413		str := d.Decor(stat)
414		stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
415		s.bufA.WriteString(str)
416		}
417		if stat.AvailableWidth < 1 {
418		trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufA.String()), tw, "…"))
419		s.bufA.Reset()
420		return io.MultiReader(s.bufP, s.bufB, trunc, nlr)
421		}
422
423		s.filler.Fill(s.bufB, s.reqWidth, stat)
424
425		return io.MultiReader(s.bufP, s.bufB, s.bufA, nlr)
426		}
427
428		func (s *bState) wSyncTable() [][]chan int {
429		columns := make([]chan int, 0, len(s.pDecorators)+len(s.aDecorators))
430		var pCount int
431		for _, d := range s.pDecorators {
432		if ch, ok := d.Sync(); ok {
433		columns = append(columns, ch)
434		pCount++
435		}
436		}
437		var aCount int
438		for _, d := range s.aDecorators {
439		if ch, ok := d.Sync(); ok {
440		columns = append(columns, ch)
441		aCount++
442		}
443		}
444		table := make([][]chan int, 2)
445		table[0] = columns[0:pCount]
446		table[1] = columns[pCount : pCount+aCount : pCount+aCount]
	533	writeFiller := func(buf *bytes.Buffer) error {
	534	return s.filler.Fill(buf, stat)
	535	}
	536	for _, fn := range []func(*bytes.Buffer) error{
	537	writeSpace,
	538	writeFiller,
	539	writeSpace,
	540	} {
	541	if err := fn(bufB); err != nil {
	542	return nil, err
	543	}
	544	}
	545	} else {
	546	err := s.filler.Fill(bufB, stat)
	547	if err != nil {
	548	return nil, err
	549	}
	550	}
	551
	552	return io.MultiReader(bufP, bufB, bufA), nil
	553	}
	554
	555	func (s *bState) wSyncTable() (table syncTable) {
	556	var count int
	557	var row []chan int
	558
	559	for i, decorators := range [][]decor.Decorator{
	560	s.pDecorators,
	561	s.aDecorators,
	562	} {
	563	for _, d := range decorators {
	564	if ch, ok := d.Sync(); ok {
	565	row = append(row, ch)
	566	count++
	567	}
	568	}
	569	switch i {
	570	case 0:
	571	table[i] = row[0:count]
	572	default:
	573	table[i] = row[len(table[i-1]):count]
	574	}
	575	}
447	576	return table
	577	}
	578
	579	func (s bState) decoratorEwmaUpdate(n int64, dur time.Duration) {
	580	var wg sync.WaitGroup
	581	for i := 0; i < len(s.ewmaDecorators); i++ {
	582	switch d := s.ewmaDecorators[i]; i {
	583	case len(s.ewmaDecorators) - 1:
	584	d.EwmaUpdate(n, dur)
	585	default:
	586	wg.Add(1)
	587	go func() {
	588	d.EwmaUpdate(n, dur)
	589	wg.Done()
	590	}()
	591	}
	592	}
	593	wg.Wait()
	594	}
	595
	596	func (s bState) decoratorAverageAdjust(start time.Time) {
	597	var wg sync.WaitGroup
	598	for i := 0; i < len(s.averageDecorators); i++ {
	599	switch d := s.averageDecorators[i]; i {
	600	case len(s.averageDecorators) - 1:
	601	d.AverageAdjust(start)
	602	default:
	603	wg.Add(1)
	604	go func() {
	605	d.AverageAdjust(start)
	606	wg.Done()
	607	}()
	608	}
	609	}
	610	wg.Wait()
	611	}
	612
	613	func (s bState) decoratorShutdownNotify() {
	614	var wg sync.WaitGroup
	615	for i := 0; i < len(s.shutdownListeners); i++ {
	616	switch d := s.shutdownListeners[i]; i {
	617	case len(s.shutdownListeners) - 1:
	618	d.OnShutdown()
	619	default:
	620	wg.Add(1)
	621	go func() {
	622	d.OnShutdown()
	623	wg.Done()
	624	}()
	625	}
	626	}
	627	wg.Wait()
448	628	}
449	629
450	630	func newStatistics(tw int, s *bState) decor.Statistics {
451	631	return decor.Statistics{
	632	AvailableWidth: tw,
	633	RequestedWidth: s.reqWidth,
452	634	ID: s.id,
453		AvailableWidth: tw,
454	635	Total: s.total,
455	636	Current: s.current,
456	637	Refill: s.refill,
457		Completed: s.completeFlushed,
458		}
459		}
460
461		func extractBaseDecorator(d decor.Decorator) decor.Decorator {
	638	Completed: s.completed,
	639	Aborted: s.aborted,
	640	}
	641	}
	642
	643	func unwrap(d decor.Decorator) decor.Decorator {
462	644	if d, ok := d.(decor.Wrapper); ok {
463		return extractBaseDecorator(d.Base())
	645	return unwrap(d.Unwrap())
464	646	}
465	647	return d
466	648	}
467	649
468		func ewmaIterationUpdate(done bool, s *bState, dur time.Duration) {
469		if !done && !s.iterated {
470		panic("increment required before ewma iteration update")
471		} else {
472		s.iterated = false
473		}
474		for _, d := range s.ewmaDecorators {
475		d.EwmaUpdate(s.lastN, dur)
476		}
477		}
478
479		func makePanicExtender(p interface{}) extenderFunc {
480		pstr := fmt.Sprint(p)
481		stack := debug.Stack()
482		stackLines := bytes.Count(stack, []byte("\n"))
483		return func(_ io.Reader, _ int, st decor.Statistics) (io.Reader, int) {
484		mr := io.MultiReader(
485		strings.NewReader(runewidth.Truncate(pstr, st.AvailableWidth, "…")),
486		strings.NewReader(fmt.Sprintf("\n%#v\n", st)),
487		bytes.NewReader(stack),
488		)
489		return mr, stackLines + 1
490		}
491		}
	650	func writeSpace(buf *bytes.Buffer) error {
	651	return buf.WriteByte(' ')
	652	}
	653
	654	func eitherError(errors ...error) error {
	655	for _, err := range errors {
	656	if err != nil {
	657	return err
	658	}
	659	}
	660	return nil
	661	}

+12

-20

bar_filler.go less more

2	2	import (
3	3	"io"
4	4
5		"github.com/vbauerster/mpb/v7/decor"
	5	"github.com/vbauerster/mpb/v8/decor"
6	6	)
7	7
8	8	// BarFiller interface.
9	9	// Bar (without decorators) renders itself by calling BarFiller's Fill method.
10		//
11		// reqWidth is requested width, set by `func WithWidth(int) ContainerOption`.
12		// If not set, it defaults to terminal width.
13		//
14		// Default implementations can be obtained via:
15		//
16		// func NewBarFiller(BarStyle()) BarFiller
17		// func NewBarFiller(SpinnerStyle()) BarFiller
18		//
19	10	type BarFiller interface {
20		Fill(w io.Writer, reqWidth int, stat decor.Statistics)
	11	Fill(io.Writer, decor.Statistics) error
21	12	}
22	13
23	14	// BarFillerBuilder interface.
	15	// Default implementations are:
	16	//
	17	// BarStyle()
	18	// SpinnerStyle()
	19	// NopStyle()
24	20	type BarFillerBuilder interface {
25	21	Build() BarFiller
26	22	}
27	23
28		// BarFillerFunc is function type adapter to convert function into BarFiller.
29		type BarFillerFunc func(w io.Writer, reqWidth int, stat decor.Statistics)
	24	// BarFillerFunc is function type adapter to convert compatible function
	25	// into BarFiller interface.
	26	type BarFillerFunc func(io.Writer, decor.Statistics) error
30	27
31		func (f BarFillerFunc) Fill(w io.Writer, reqWidth int, stat decor.Statistics) {
32		f(w, reqWidth, stat)
	28	func (f BarFillerFunc) Fill(w io.Writer, stat decor.Statistics) error {
	29	return f(w, stat)
33	30	}
34
35		// NewBarFiller constructs a BarFiller from provided BarFillerBuilder.
36		func NewBarFiller(b BarFillerBuilder) BarFiller {
37		return b.Build()
38		}

+240

-168

bar_filler_bar.go less more

2	2	import (
3	3	"io"
4	4
5		"github.com/acarl005/stripansi"
6	5	"github.com/mattn/go-runewidth"
7		"github.com/vbauerster/mpb/v7/decor"
8		"github.com/vbauerster/mpb/v7/internal"
	6	"github.com/vbauerster/mpb/v8/decor"
	7	"github.com/vbauerster/mpb/v8/internal"
9	8	)
10	9
11	10	const (
12	11	iLbound = iota
13	12	iRbound
	13	iRefiller
14	14	iFiller
15		iRefiller
	15	iTip
16	16	iPadding
17	17	components
18	18	)
	19
	20	var defaultBarStyle = [components]string{"[", "]", "+", "=", ">", "-"}
19	21
20	22	// BarStyleComposer interface.
21	23	type BarStyleComposer interface {
22	24	BarFillerBuilder
23	25	Lbound(string) BarStyleComposer
	26	LboundMeta(func(string) string) BarStyleComposer
24	27	Rbound(string) BarStyleComposer
	28	RboundMeta(func(string) string) BarStyleComposer
25	29	Filler(string) BarStyleComposer
	30	FillerMeta(func(string) string) BarStyleComposer
26	31	Refiller(string) BarStyleComposer
	32	RefillerMeta(func(string) string) BarStyleComposer
27	33	Padding(string) BarStyleComposer
28		Tip(...string) BarStyleComposer
	34	PaddingMeta(func(string) string) BarStyleComposer
	35	Tip(frames ...string) BarStyleComposer
	36	TipMeta(func(string) string) BarStyleComposer
	37	TipOnComplete() BarStyleComposer
29	38	Reverse() BarStyleComposer
30		}
31
32		type bFiller struct {
33		components [components]*component
34		tip struct {
35		count uint
36		frames []*component
37		}
38		flush func(dst io.Writer, filling, padding [][]byte)
39	39	}
40	40
41	41	type component struct {

43	43	bytes []byte
44	44	}
45	45
	46	type flushSection struct {
	47	meta func(io.Writer, []byte) error
	48	bytes []byte
	49	}
	50
	51	type bFiller struct {
	52	components [components]component
	53	meta [components]func(io.Writer, []byte) error
	54	flush func(io.Writer, ...flushSection) error
	55	tipOnComplete bool
	56	tip struct {
	57	frames []component
	58	count uint
	59	}
	60	}
	61
46	62	type barStyle struct {
47		lbound string
48		rbound string
49		filler string
50		refiller string
51		padding string
52		tip []string
53		rev bool
	63	style [components]string
	64	metaFuncs [components]func(io.Writer, []byte) error
	65	tipFrames []string
	66	tipOnComplete bool
	67	rev bool
54	68	}
55	69
56	70	// BarStyle constructs default bar style which can be altered via
57	71	// BarStyleComposer interface.
58	72	func BarStyle() BarStyleComposer {
59		return &barStyle{
60		lbound: "[",
61		rbound: "]",
62		filler: "=",
63		refiller: "+",
64		padding: "-",
65		tip: []string{">"},
66		}
67		}
68
69		func (s *barStyle) Lbound(bound string) BarStyleComposer {
70		s.lbound = bound
71		return s
72		}
73
74		func (s *barStyle) Rbound(bound string) BarStyleComposer {
75		s.rbound = bound
76		return s
77		}
78
79		func (s *barStyle) Filler(filler string) BarStyleComposer {
80		s.filler = filler
81		return s
82		}
83
84		func (s *barStyle) Refiller(refiller string) BarStyleComposer {
85		s.refiller = refiller
86		return s
87		}
88
89		func (s *barStyle) Padding(padding string) BarStyleComposer {
90		s.padding = padding
91		return s
92		}
93
94		func (s *barStyle) Tip(tip ...string) BarStyleComposer {
95		if len(tip) != 0 {
96		s.tip = append(s.tip[:0], tip...)
97		}
98		return s
99		}
100
101		func (s *barStyle) Reverse() BarStyleComposer {
	73	bs := barStyle{
	74	style: defaultBarStyle,
	75	tipFrames: []string{defaultBarStyle[iTip]},
	76	}
	77	for i := range bs.metaFuncs {
	78	bs.metaFuncs[i] = defaultMeta
	79	}
	80	return bs
	81	}
	82
	83	func (s barStyle) Lbound(bound string) BarStyleComposer {
	84	s.style[iLbound] = bound
	85	return s
	86	}
	87
	88	func (s barStyle) LboundMeta(fn func(string) string) BarStyleComposer {
	89	s.metaFuncs[iLbound] = makeMetaFunc(fn)
	90	return s
	91	}
	92
	93	func (s barStyle) Rbound(bound string) BarStyleComposer {
	94	s.style[iRbound] = bound
	95	return s
	96	}
	97
	98	func (s barStyle) RboundMeta(fn func(string) string) BarStyleComposer {
	99	s.metaFuncs[iRbound] = makeMetaFunc(fn)
	100	return s
	101	}
	102
	103	func (s barStyle) Filler(filler string) BarStyleComposer {
	104	s.style[iFiller] = filler
	105	return s
	106	}
	107
	108	func (s barStyle) FillerMeta(fn func(string) string) BarStyleComposer {
	109	s.metaFuncs[iFiller] = makeMetaFunc(fn)
	110	return s
	111	}
	112
	113	func (s barStyle) Refiller(refiller string) BarStyleComposer {
	114	s.style[iRefiller] = refiller
	115	return s
	116	}
	117
	118	func (s barStyle) RefillerMeta(fn func(string) string) BarStyleComposer {
	119	s.metaFuncs[iRefiller] = makeMetaFunc(fn)
	120	return s
	121	}
	122
	123	func (s barStyle) Padding(padding string) BarStyleComposer {
	124	s.style[iPadding] = padding
	125	return s
	126	}
	127
	128	func (s barStyle) PaddingMeta(fn func(string) string) BarStyleComposer {
	129	s.metaFuncs[iPadding] = makeMetaFunc(fn)
	130	return s
	131	}
	132
	133	func (s barStyle) Tip(frames ...string) BarStyleComposer {
	134	if len(frames) != 0 {
	135	s.tipFrames = frames
	136	}
	137	return s
	138	}
	139
	140	func (s barStyle) TipMeta(fn func(string) string) BarStyleComposer {
	141	s.metaFuncs[iTip] = makeMetaFunc(fn)
	142	return s
	143	}
	144
	145	func (s barStyle) TipOnComplete() BarStyleComposer {
	146	s.tipOnComplete = true
	147	return s
	148	}
	149
	150	func (s barStyle) Reverse() BarStyleComposer {
102	151	s.rev = true
103	152	return s
104	153	}
105	154
106		func (s *barStyle) Build() BarFiller {
107		bf := new(bFiller)
	155	func (s barStyle) Build() BarFiller {
	156	bf := &bFiller{
	157	meta: s.metaFuncs,
	158	tipOnComplete: s.tipOnComplete,
	159	}
	160	bf.components[iLbound] = component{
	161	width: runewidth.StringWidth(s.style[iLbound]),
	162	bytes: []byte(s.style[iLbound]),
	163	}
	164	bf.components[iRbound] = component{
	165	width: runewidth.StringWidth(s.style[iRbound]),
	166	bytes: []byte(s.style[iRbound]),
	167	}
	168	bf.components[iFiller] = component{
	169	width: runewidth.StringWidth(s.style[iFiller]),
	170	bytes: []byte(s.style[iFiller]),
	171	}
	172	bf.components[iRefiller] = component{
	173	width: runewidth.StringWidth(s.style[iRefiller]),
	174	bytes: []byte(s.style[iRefiller]),
	175	}
	176	bf.components[iPadding] = component{
	177	width: runewidth.StringWidth(s.style[iPadding]),
	178	bytes: []byte(s.style[iPadding]),
	179	}
	180	bf.tip.frames = make([]component, len(s.tipFrames))
	181	for i, t := range s.tipFrames {
	182	bf.tip.frames[i] = component{
	183	width: runewidth.StringWidth(t),
	184	bytes: []byte(t),
	185	}
	186	}
108	187	if s.rev {
109		bf.flush = func(dst io.Writer, filling, padding [][]byte) {
110		flush(dst, padding, filling)
	188	bf.flush = func(w io.Writer, sections ...flushSection) error {
	189	for i := len(sections) - 1; i >= 0; i-- {
	190	if s := sections[i]; len(s.bytes) != 0 {
	191	err := s.meta(w, s.bytes)
	192	if err != nil {
	193	return err
	194	}
	195	}
	196	}
	197	return nil
111	198	}
112	199	} else {
113		bf.flush = flush
114		}
115		bf.components[iLbound] = &component{
116		width: runewidth.StringWidth(stripansi.Strip(s.lbound)),
117		bytes: []byte(s.lbound),
118		}
119		bf.components[iRbound] = &component{
120		width: runewidth.StringWidth(stripansi.Strip(s.rbound)),
121		bytes: []byte(s.rbound),
122		}
123		bf.components[iFiller] = &component{
124		width: runewidth.StringWidth(stripansi.Strip(s.filler)),
125		bytes: []byte(s.filler),
126		}
127		bf.components[iRefiller] = &component{
128		width: runewidth.StringWidth(stripansi.Strip(s.refiller)),
129		bytes: []byte(s.refiller),
130		}
131		bf.components[iPadding] = &component{
132		width: runewidth.StringWidth(stripansi.Strip(s.padding)),
133		bytes: []byte(s.padding),
134		}
135		bf.tip.frames = make([]*component, len(s.tip))
136		for i, t := range s.tip {
137		bf.tip.frames[i] = &component{
138		width: runewidth.StringWidth(stripansi.Strip(t)),
139		bytes: []byte(t),
	200	bf.flush = func(w io.Writer, sections ...flushSection) error {
	201	for _, s := range sections {
	202	if len(s.bytes) != 0 {
	203	err := s.meta(w, s.bytes)
	204	if err != nil {
	205	return err
	206	}
	207	}
	208	}
	209	return nil
140	210	}
141	211	}
142	212	return bf
143	213	}
144	214
145		func (s *bFiller) Fill(w io.Writer, width int, stat decor.Statistics) {
146		width = internal.CheckRequestedWidth(width, stat.AvailableWidth)
147		brackets := s.components[iLbound].width + s.components[iRbound].width
148		if width < brackets {
149		return
150		}
	215	func (s *bFiller) Fill(w io.Writer, stat decor.Statistics) error {
	216	width := internal.CheckRequestedWidth(stat.RequestedWidth, stat.AvailableWidth)
151	217	// don't count brackets as progress
152		width -= brackets
153
154		w.Write(s.components[iLbound].bytes)
155		defer w.Write(s.components[iRbound].bytes)
156
157		curWidth := int(internal.PercentageRound(stat.Total, stat.Current, width))
158		refWidth, filled := 0, curWidth
159		filling := make([][]byte, 0, curWidth)
160
161		if curWidth > 0 && curWidth != width {
162		tipFrame := s.tip.frames[s.tip.count%uint(len(s.tip.frames))]
163		filling = append(filling, tipFrame.bytes)
164		curWidth -= tipFrame.width
165		s.tip.count++
166		}
167
168		if stat.Refill > 0 && curWidth > 0 {
169		refWidth = int(internal.PercentageRound(stat.Total, int64(stat.Refill), width))
170		if refWidth > curWidth {
171		refWidth = curWidth
172		}
173		curWidth -= refWidth
174		}
175
176		for curWidth > 0 && curWidth >= s.components[iFiller].width {
177		filling = append(filling, s.components[iFiller].bytes)
178		curWidth -= s.components[iFiller].width
179		if s.components[iFiller].width == 0 {
180		break
181		}
182		}
183
184		for refWidth > 0 && refWidth >= s.components[iRefiller].width {
185		filling = append(filling, s.components[iRefiller].bytes)
186		refWidth -= s.components[iRefiller].width
187		if s.components[iRefiller].width == 0 {
188		break
189		}
190		}
191
192		filled -= curWidth + refWidth
193		padWidth := width - filled
194		padding := make([][]byte, 0, padWidth)
195		for padWidth > 0 && padWidth >= s.components[iPadding].width {
196		padding = append(padding, s.components[iPadding].bytes)
197		padWidth -= s.components[iPadding].width
198		if s.components[iPadding].width == 0 {
199		break
200		}
201		}
202
203		for padWidth > 0 {
204		padding = append(padding, []byte("…"))
205		padWidth--
206		}
207
208		s.flush(w, filling, padding)
209		}
210
211		func flush(dst io.Writer, filling, padding [][]byte) {
212		for i := len(filling) - 1; i >= 0; i-- {
213		dst.Write(filling[i])
214		}
215		for i := 0; i < len(padding); i++ {
216		dst.Write(padding[i])
217		}
218		}
	218	width -= (s.components[iLbound].width + s.components[iRbound].width)
	219	if width < 0 {
	220	return nil
	221	}
	222
	223	err := s.meta[iLbound](w, s.components[iLbound].bytes)
	224	if err != nil {
	225	return err
	226	}
	227
	228	if width == 0 {
	229	return s.meta[iRbound](w, s.components[iRbound].bytes)
	230	}
	231
	232	var tip component
	233	var refilling, filling, padding []byte
	234	var fillCount int
	235	curWidth := int(internal.PercentageRound(stat.Total, stat.Current, uint(width)))
	236
	237	if curWidth != 0 {
	238	if !stat.Completed \|\| s.tipOnComplete {
	239	tip = s.tip.frames[s.tip.count%uint(len(s.tip.frames))]
	240	s.tip.count++
	241	fillCount += tip.width
	242	}
	243	if stat.Refill != 0 {
	244	refWidth := int(internal.PercentageRound(stat.Total, stat.Refill, uint(width)))
	245	curWidth -= refWidth
	246	refWidth += curWidth
	247	for w := s.components[iFiller].width; curWidth-fillCount >= w; fillCount += w {
	248	filling = append(filling, s.components[iFiller].bytes...)
	249	}
	250	for w := s.components[iRefiller].width; refWidth-fillCount >= w; fillCount += w {
	251	refilling = append(refilling, s.components[iRefiller].bytes...)
	252	}
	253	} else {
	254	for w := s.components[iFiller].width; curWidth-fillCount >= w; fillCount += w {
	255	filling = append(filling, s.components[iFiller].bytes...)
	256	}
	257	}
	258	}
	259
	260	for w := s.components[iPadding].width; width-fillCount >= w; fillCount += w {
	261	padding = append(padding, s.components[iPadding].bytes...)
	262	}
	263
	264	for w := 1; width-fillCount >= w; fillCount += w {
	265	padding = append(padding, "…"...)
	266	}
	267
	268	err = s.flush(w,
	269	flushSection{s.meta[iRefiller], refilling},
	270	flushSection{s.meta[iFiller], filling},
	271	flushSection{s.meta[iTip], tip.bytes},
	272	flushSection{s.meta[iPadding], padding},
	273	)
	274	if err != nil {
	275	return err
	276	}
	277	return s.meta[iRbound](w, s.components[iRbound].bytes)
	278	}
	279
	280	func makeMetaFunc(fn func(string) string) func(io.Writer, []byte) error {
	281	return func(w io.Writer, p []byte) (err error) {
	282	_, err = io.WriteString(w, fn(string(p)))
	283	return err
	284	}
	285	}
	286
	287	func defaultMeta(w io.Writer, p []byte) (err error) {
	288	_, err = w.Write(p)
	289	return err
	290	}

+24

-0

bar_filler_nop.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4
	5	"github.com/vbauerster/mpb/v8/decor"
	6	)
	7
	8	// barFillerBuilderFunc is function type adapter to convert compatible
	9	// function into BarFillerBuilder interface.
	10	type barFillerBuilderFunc func() BarFiller
	11
	12	func (f barFillerBuilderFunc) Build() BarFiller {
	13	return f()
	14	}
	15
	16	// NopStyle provides BarFillerBuilder which builds NOP BarFiller.
	17	func NopStyle() BarFillerBuilder {
	18	return barFillerBuilderFunc(func() BarFiller {
	19	return BarFillerFunc(func(io.Writer, decor.Statistics) error {
	20	return nil
	21	})
	22	})
	23	}

+45

-29

bar_filler_spinner.go less more

3	3	"io"
4	4	"strings"
5	5
6		"github.com/acarl005/stripansi"
7	6	"github.com/mattn/go-runewidth"
8		"github.com/vbauerster/mpb/v7/decor"
9		"github.com/vbauerster/mpb/v7/internal"
	7	"github.com/vbauerster/mpb/v8/decor"
	8	"github.com/vbauerster/mpb/v8/internal"
10	9	)
11	10
12	11	const (

14	13	positionRight
15	14	)
16	15
	16	var defaultSpinnerStyle = [...]string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	17
17	18	// SpinnerStyleComposer interface.
18	19	type SpinnerStyleComposer interface {
19	20	BarFillerBuilder
20	21	PositionLeft() SpinnerStyleComposer
21	22	PositionRight() SpinnerStyleComposer
	23	Meta(func(string) string) SpinnerStyleComposer
22	24	}
23	25
24	26	type sFiller struct {
	27	frames []string
25	28	count uint
26		position uint
27		frames []string
	29	meta func(string) string
	30	position func(string, int) string
28	31	}
29	32
30	33	type spinnerStyle struct {
31	34	position uint
32	35	frames []string
	36	meta func(string) string
33	37	}
34	38
35	39	// SpinnerStyle constructs default spinner style which can be altered via
36	40	// SpinnerStyleComposer interface.
37	41	func SpinnerStyle(frames ...string) SpinnerStyleComposer {
38		ss := new(spinnerStyle)
	42	ss := spinnerStyle{
	43	meta: func(s string) string { return s },
	44	}
39	45	if len(frames) != 0 {
40		ss.frames = append(ss.frames, frames...)
	46	ss.frames = frames
41	47	} else {
42		ss.frames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	48	ss.frames = defaultSpinnerStyle[:]
43	49	}
44	50	return ss
45	51	}
46	52
47		func (s *spinnerStyle) PositionLeft() SpinnerStyleComposer {
	53	func (s spinnerStyle) PositionLeft() SpinnerStyleComposer {
48	54	s.position = positionLeft
49	55	return s
50	56	}
51	57
52		func (s *spinnerStyle) PositionRight() SpinnerStyleComposer {
	58	func (s spinnerStyle) PositionRight() SpinnerStyleComposer {
53	59	s.position = positionRight
54	60	return s
55	61	}
56	62
57		func (s *spinnerStyle) Build() BarFiller {
	63	func (s spinnerStyle) Meta(fn func(string) string) SpinnerStyleComposer {
	64	s.meta = fn
	65	return s
	66	}
	67
	68	func (s spinnerStyle) Build() BarFiller {
58	69	sf := &sFiller{
59		position: s.position,
60		frames: s.frames,
	70	frames: s.frames,
	71	meta: s.meta,
	72	}
	73	switch s.position {
	74	case positionLeft:
	75	sf.position = func(frame string, padWidth int) string {
	76	return frame + strings.Repeat(" ", padWidth)
	77	}
	78	case positionRight:
	79	sf.position = func(frame string, padWidth int) string {
	80	return strings.Repeat(" ", padWidth) + frame
	81	}
	82	default:
	83	sf.position = func(frame string, padWidth int) string {
	84	return strings.Repeat(" ", padWidth/2) + frame + strings.Repeat(" ", padWidth/2+padWidth%2)
	85	}
61	86	}
62	87	return sf
63	88	}
64	89
65		func (s *sFiller) Fill(w io.Writer, width int, stat decor.Statistics) {
66		width = internal.CheckRequestedWidth(width, stat.AvailableWidth)
67
	90	func (s *sFiller) Fill(w io.Writer, stat decor.Statistics) error {
	91	width := internal.CheckRequestedWidth(stat.RequestedWidth, stat.AvailableWidth)
68	92	frame := s.frames[s.count%uint(len(s.frames))]
69		frameWidth := runewidth.StringWidth(stripansi.Strip(frame))
	93	frameWidth := runewidth.StringWidth(frame)
	94	s.count++
70	95
71	96	if width < frameWidth {
72		return
	97	return nil
73	98	}
74	99
75		rest := width - frameWidth
76		switch s.position {
77		case positionLeft:
78		io.WriteString(w, frame+strings.Repeat(" ", rest))
79		case positionRight:
80		io.WriteString(w, strings.Repeat(" ", rest)+frame)
81		default:
82		str := strings.Repeat(" ", rest/2) + frame + strings.Repeat(" ", rest/2+rest%2)
83		io.WriteString(w, str)
84		}
85		s.count++
	100	_, err := io.WriteString(w, s.position(s.meta(frame), width-frameWidth))
	101	return err
86	102	}

+97

-50

bar_option.go less more

3	3	"bytes"
4	4	"io"
5	5
6		"github.com/vbauerster/mpb/v7/decor"
7		"github.com/vbauerster/mpb/v7/internal"
	6	"github.com/vbauerster/mpb/v8/decor"
8	7	)
9	8
10	9	// BarOption is a func option to alter default behavior of a bar.
11	10	type BarOption func(*bState)
12	11
13		func (s bState) addDecorators(dest []decor.Decorator, decorators ...decor.Decorator) {
14		type mergeWrapper interface {
15		MergeUnwrap() []decor.Decorator
16		}
	12	func inspect(decorators []decor.Decorator) (dest []decor.Decorator) {
17	13	for _, decorator := range decorators {
18		if mw, ok := decorator.(mergeWrapper); ok {
19		dest = append(dest, mw.MergeUnwrap()...)
20		}
21		dest = append(dest, decorator)
22		}
	14	if decorator == nil {
	15	continue
	16	}
	17	dest = append(dest, decorator)
	18	}
	19	return
23	20	}
24	21
25	22	// AppendDecorators let you inject decorators to the bar's right side.
26	23	func AppendDecorators(decorators ...decor.Decorator) BarOption {
27		return func(s *bState) {
28		s.addDecorators(&s.aDecorators, decorators...)
	24	decorators = inspect(decorators)
	25	return func(s *bState) {
	26	s.aDecorators = decorators
29	27	}
30	28	}
31	29
32	30	// PrependDecorators let you inject decorators to the bar's left side.
33	31	func PrependDecorators(decorators ...decor.Decorator) BarOption {
34		return func(s *bState) {
35		s.addDecorators(&s.pDecorators, decorators...)
	32	decorators = inspect(decorators)
	33	return func(s *bState) {
	34	s.pDecorators = decorators
36	35	}
37	36	}
38	37

50	49	}
51	50	}
52	51
53		// BarQueueAfter queues this (being constructed) bar to relplace
54		// runningBar after it has been completed.
55		func BarQueueAfter(runningBar *Bar) BarOption {
56		if runningBar == nil {
57		return nil
58		}
59		return func(s *bState) {
60		s.runningBar = runningBar
	52	// BarQueueAfter puts this (being constructed) bar into the queue.
	53	// BarPriority will be inherited from the argument bar.
	54	// When argument bar completes or aborts queued bar replaces its place.
	55	func BarQueueAfter(bar *Bar) BarOption {
	56	return func(s *bState) {
	57	s.waitBar = bar
61	58	}
62	59	}
63	60

65	62	// on complete event.
66	63	func BarRemoveOnComplete() BarOption {
67	64	return func(s *bState) {
68		s.dropOnComplete = true
	65	s.rmOnComplete = true
69	66	}
70	67	}
71	68

78	75	// BarFillerOnComplete replaces bar's filler with message, on complete event.
79	76	func BarFillerOnComplete(message string) BarOption {
80	77	return BarFillerMiddleware(func(base BarFiller) BarFiller {
81		return BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
	78	return BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
82	79	if st.Completed {
83		io.WriteString(w, message)
84		} else {
85		base.Fill(w, reqWidth, st)
	80	_, err := io.WriteString(w, message)
	81	return err
86	82	}
	83	return base.Fill(w, st)
87	84	})
88	85	})
89	86	}
90	87
91	88	// BarFillerMiddleware provides a way to augment the underlying BarFiller.
92	89	func BarFillerMiddleware(middle func(BarFiller) BarFiller) BarOption {
93		return func(s *bState) {
94		s.middleware = middle
	90	if middle == nil {
	91	return nil
	92	}
	93	return func(s *bState) {
	94	s.filler = middle(s.filler)
95	95	}
96	96	}
97	97
98	98	// BarPriority sets bar's priority. Zero is highest priority, i.e. bar
99		// will be on top. If `BarReplaceOnComplete` option is supplied, this
100		// option is ignored.
	99	// will be on top. This option isn't effective with `BarQueueAfter` option.
101	100	func BarPriority(priority int) BarOption {
102	101	return func(s *bState) {
103	102	s.priority = priority
104	103	}
105	104	}
106	105
107		// BarExtender provides a way to extend bar to the next new line.
108		func BarExtender(filler BarFiller) BarOption {
	106	// BarExtender extends bar with arbitrary lines. Provided BarFiller will be
	107	// called at each render/flush cycle. Any lines written to the underlying
	108	// io.Writer will extend the bar either in above (rev = true) or below
	109	// (rev = false) direction.
	110	func BarExtender(filler BarFiller, rev bool) BarOption {
109	111	if filler == nil {
110	112	return nil
111	113	}
112		return func(s *bState) {
113		s.extender = makeExtenderFunc(filler)
114		}
115		}
116
117		func makeExtenderFunc(filler BarFiller) extenderFunc {
	114	fn := makeExtenderFunc(filler, rev)
	115	return func(s *bState) {
	116	s.extender = fn
	117	}
	118	}
	119
	120	func makeExtenderFunc(filler BarFiller, rev bool) extenderFunc {
118	121	buf := new(bytes.Buffer)
119		return func(r io.Reader, reqWidth int, st decor.Statistics) (io.Reader, int) {
120		filler.Fill(buf, reqWidth, st)
121		return io.MultiReader(r, buf), bytes.Count(buf.Bytes(), []byte("\n"))
	122	base := func(rows []io.Reader, stat decor.Statistics) ([]io.Reader, error) {
	123	err := filler.Fill(buf, stat)
	124	if err != nil {
	125	buf.Reset()
	126	return rows, err
	127	}
	128	for {
	129	b, err := buf.ReadBytes('\n')
	130	if err != nil {
	131	break
	132	}
	133	rows = append(rows, bytes.NewReader(b))
	134	}
	135	buf.Reset()
	136	return rows, err
	137	}
	138
	139	if !rev {
	140	return base
	141	}
	142	return func(rows []io.Reader, stat decor.Statistics) ([]io.Reader, error) {
	143	rows, err := base(rows, stat)
	144	if err != nil {
	145	return rows, err
	146	}
	147	for left, right := 0, len(rows)-1; left < right; left, right = left+1, right-1 {
	148	rows[left], rows[right] = rows[right], rows[left]
	149	}
	150	return rows, err
122	151	}
123	152	}
124	153

137	166	}
138	167	}
139	168
140		// BarOptional will invoke provided option only when pick is true.
141		func BarOptional(option BarOption, pick bool) BarOption {
142		return BarOptOn(option, internal.Predicate(pick))
143		}
144
145		// BarOptOn will invoke provided option only when higher order predicate
146		// evaluates to true.
	169	// BarOptional will return provided option only when cond is true.
	170	func BarOptional(option BarOption, cond bool) BarOption {
	171	if cond {
	172	return option
	173	}
	174	return nil
	175	}
	176
	177	// BarOptOn will return provided option only when predicate evaluates to true.
147	178	func BarOptOn(option BarOption, predicate func() bool) BarOption {
148	179	if predicate() {
149	180	return option
150	181	}
151	182	return nil
152	183	}
	184
	185	// BarFuncOptional will call option and return its value only when cond is true.
	186	func BarFuncOptional(option func() BarOption, cond bool) BarOption {
	187	if cond {
	188	return option()
	189	}
	190	return nil
	191	}
	192
	193	// BarFuncOptOn will call option and return its value only when predicate evaluates to true.
	194	func BarFuncOptOn(option func() BarOption, predicate func() bool) BarOption {
	195	if predicate() {
	196	return option()
	197	}
	198	return nil
	199	}

+201

-211

bar_test.go less more

1	1
2	2	import (
3	3	"bytes"
	4	"context"
4	5	"fmt"
5		"io/ioutil"
	6	"io"
6	7	"strings"
7		"sync/atomic"
8	8	"testing"
9	9	"time"
10	10	"unicode/utf8"
11	11
12		"github.com/vbauerster/mpb/v7"
13		"github.com/vbauerster/mpb/v7/decor"
	12	"github.com/vbauerster/mpb/v8"
	13	"github.com/vbauerster/mpb/v8/decor"
14	14	)
15	15
16	16	func TestBarCompleted(t *testing.T) {
17		p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(ioutil.Discard))
	17	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
18	18	total := 80
19	19	bar := p.AddBar(int64(total))
20	20
21		var count int
22		for !bar.Completed() {
23		time.Sleep(10 * time.Millisecond)
24		bar.Increment()
25		count++
26		}
27
28		p.Wait()
29		if count != total {
30		t.Errorf("got count: %d, expected %d\n", count, total)
31		}
	21	if bar.Completed() {
	22	t.Fail()
	23	}
	24
	25	bar.IncrBy(total)
	26
	27	if !bar.Completed() {
	28	t.Error("bar isn't completed after increment")
	29	}
	30
	31	p.Wait()
	32	}
	33
	34	func TestBarAborted(t *testing.T) {
	35	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
	36	total := 80
	37	bar := p.AddBar(int64(total))
	38
	39	if bar.Aborted() {
	40	t.Fail()
	41	}
	42
	43	bar.Abort(false)
	44
	45	if !bar.Aborted() {
	46	t.Error("bar isn't aborted after abort call")
	47	}
	48
	49	p.Wait()
	50	}
	51
	52	func TestBarSetTotal(t *testing.T) {
	53	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
	54	bar := p.AddBar(0)
	55
	56	bar.SetTotal(0, false)
	57	if bar.Completed() {
	58	t.Error("expected bar not to complete")
	59	}
	60
	61	bar.SetTotal(0, true)
	62	if !bar.Completed() {
	63	t.Error("expected bar to complete")
	64	}
	65
	66	p.Wait()
	67	}
	68
	69	func TestBarEnableTriggerCompleteAndIncrementBefore(t *testing.T) {
	70	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
	71	bar := p.AddBar(0) // never complete bar
	72
	73	for _, f := range []func(){
	74	func() { bar.SetTotal(40, false) },
	75	func() { bar.IncrBy(60) },
	76	func() { bar.SetTotal(80, false) },
	77	func() { bar.IncrBy(20) },
	78	} {
	79	f()
	80	if bar.Completed() {
	81	t.Fail()
	82	}
	83	}
	84
	85	bar.EnableTriggerComplete()
	86
	87	if !bar.Completed() {
	88	t.Fail()
	89	}
	90
	91	p.Wait()
	92	}
	93
	94	func TestBarEnableTriggerCompleteAndIncrementAfter(t *testing.T) {
	95	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
	96	bar := p.AddBar(0) // never complete bar
	97
	98	for _, f := range []func(){
	99	func() { bar.SetTotal(40, false) },
	100	func() { bar.IncrBy(60) },
	101	func() { bar.SetTotal(80, false) },
	102	func() { bar.EnableTriggerComplete() },
	103	} {
	104	f()
	105	if bar.Completed() {
	106	t.Fail()
	107	}
	108	}
	109
	110	bar.IncrBy(20)
	111
	112	if !bar.Completed() {
	113	t.Fail()
	114	}
	115
	116	p.Wait()
32	117	}
33	118
34	119	func TestBarID(t *testing.T) {
35		p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(ioutil.Discard))
	120	p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(io.Discard))
36	121	total := 100
37	122	wantID := 11
38	123	bar := p.AddBar(int64(total), mpb.BarID(wantID))
39	124
40		go func() {
41		for i := 0; i < total; i++ {
42		time.Sleep(50 * time.Millisecond)
43		bar.Increment()
44		}
45		}()
46
47	125	gotID := bar.ID()
48	126	if gotID != wantID {
49		t.Errorf("Expected bar id: %d, got %d\n", wantID, gotID)
50		}
51
52		bar.Abort(true)
	127	t.Errorf("Expected bar id: %d, got %d", wantID, gotID)
	128	}
	129
	130	bar.IncrBy(total)
	131
53	132	p.Wait()
54	133	}
55	134
56	135	func TestBarSetRefill(t *testing.T) {
57	136	var buf bytes.Buffer
58
59		p := mpb.New(mpb.WithOutput(&buf), mpb.WithWidth(100))
	137	p := mpb.New(
	138	mpb.WithWidth(100),
	139	mpb.WithOutput(&buf),
	140	mpb.WithAutoRefresh(),
	141	)
60	142
61	143	total := 100
62	144	till := 30
63	145	refiller := "+"
64	146
65		bar := p.Add(int64(total), mpb.NewBarFiller(mpb.BarStyle().Refiller(refiller)), mpb.BarFillerTrim())
66
	147	bar := p.New(int64(total), mpb.BarStyle().Refiller(refiller), mpb.BarFillerTrim())
	148
	149	bar.IncrBy(till)
67	150	bar.SetRefill(int64(till))
68		bar.IncrBy(till)
69
70		for i := 0; i < total-till; i++ {
71		bar.Increment()
72		time.Sleep(10 * time.Millisecond)
73		}
	151	bar.IncrBy(total - till)
74	152
75	153	p.Wait()
76	154

79	157	strings.Repeat("=", total-till-1),
80	158	)
81	159
82		got := string(getLastLine(buf.Bytes()))
	160	got := string(bytes.Split(buf.Bytes(), []byte("\n"))[0])
83	161
84	162	if !strings.Contains(got, wantBar) {
85		t.Errorf("Want bar: %q, got bar: %q\n", wantBar, got)
86		}
87		}
88
89		func TestBarHas100PercentWithOnCompleteDecorator(t *testing.T) {
90		var buf bytes.Buffer
91
92		p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(&buf))
93
94		total := 50
95
96		bar := p.AddBar(int64(total),
97		mpb.AppendDecorators(
98		decor.OnComplete(
99		decor.Percentage(), "done",
100		),
101		),
102		)
103
104		for i := 0; i < total; i++ {
105		bar.Increment()
106		time.Sleep(10 * time.Millisecond)
107		}
108
109		p.Wait()
110
111		hundred := "100 %"
112		if !bytes.Contains(buf.Bytes(), []byte(hundred)) {
113		t.Errorf("Bar's buffer does not contain: %q\n", hundred)
	163	t.Errorf("Want bar: %q, got bar: %q", wantBar, got)
114	164	}
115	165	}
116	166
117	167	func TestBarHas100PercentWithBarRemoveOnComplete(t *testing.T) {
118	168	var buf bytes.Buffer
119
120		p := mpb.New(mpb.WithWidth(80), mpb.WithOutput(&buf))
	169	p := mpb.New(
	170	mpb.WithWidth(80),
	171	mpb.WithOutput(&buf),
	172	mpb.WithAutoRefresh(),
	173	)
121	174
122	175	total := 50
123	176

126	179	mpb.AppendDecorators(decor.Percentage()),
127	180	)
128	181
129		for i := 0; i < total; i++ {
130		bar.Increment()
131		time.Sleep(10 * time.Millisecond)
132		}
	182	bar.IncrBy(total)
133	183
134	184	p.Wait()
135	185
136	186	hundred := "100 %"
137	187	if !bytes.Contains(buf.Bytes(), []byte(hundred)) {
138		t.Errorf("Bar's buffer does not contain: %q\n", hundred)
	188	t.Errorf("Bar's buffer does not contain: %q", hundred)
139	189	}
140	190	}
141	191

144	194	customFormat := "╢▌▌░╟"
145	195	runes := []rune(customFormat)
146	196	total := 80
147		p := mpb.New(mpb.WithWidth(total), mpb.WithOutput(&buf))
	197	p := mpb.New(
	198	mpb.WithWidth(80),
	199	mpb.WithOutput(&buf),
	200	mpb.WithAutoRefresh(),
	201	)
148	202	bs := mpb.BarStyle()
149		bs.Lbound(string(runes[0]))
150		bs.Filler(string(runes[1]))
151		bs.Tip(string(runes[2]))
152		bs.Padding(string(runes[3]))
153		bs.Rbound(string(runes[4]))
154		bar := p.Add(int64(total), mpb.NewBarFiller(bs), mpb.BarFillerTrim())
155
156		for i := 0; i < total; i++ {
157		bar.Increment()
158		time.Sleep(10 * time.Millisecond)
159		}
	203	bs = bs.Lbound(string(runes[0]))
	204	bs = bs.Filler(string(runes[1]))
	205	bs = bs.Tip(string(runes[2]))
	206	bs = bs.Padding(string(runes[3]))
	207	bs = bs.Rbound(string(runes[4]))
	208	bar := p.New(int64(total), bs, mpb.BarFillerTrim())
	209
	210	bar.IncrBy(total)
160	211
161	212	p.Wait()
162	213

166	217	string(runes[2]),
167	218	string(runes[4]),
168	219	)
169		got := string(getLastLine(buf.Bytes()))
	220	got := string(bytes.Split(buf.Bytes(), []byte("\n"))[0])
170	221
171	222	if !strings.Contains(got, wantBar) {
172		t.Errorf("Want bar: %q:%d, got bar: %q:%d\n", wantBar, utf8.RuneCountInString(wantBar), got, utf8.RuneCountInString(got))
173		}
174		}
175
176		func TestBarPanicBeforeComplete(t *testing.T) {
177		var buf bytes.Buffer
178		p := mpb.New(
179		mpb.WithWidth(80),
180		mpb.WithDebugOutput(&buf),
181		mpb.WithOutput(ioutil.Discard),
182		)
183
184		total := 100
185		panicMsg := "Upps!!!"
186		var pCount uint32
187		bar := p.AddBar(int64(total),
188		mpb.PrependDecorators(panicDecorator(panicMsg,
189		func(st decor.Statistics) bool {
190		if st.Current >= 42 {
191		atomic.AddUint32(&pCount, 1)
192		return true
193		}
194		return false
195		},
196		)),
197		)
198
199		for i := 0; i < total; i++ {
200		time.Sleep(10 * time.Millisecond)
201		bar.Increment()
202		}
203
204		p.Wait()
205
206		if pCount != 1 {
207		t.Errorf("Decor called after panic %d times\n", pCount-1)
208		}
209
210		barStr := buf.String()
211		if !strings.Contains(barStr, panicMsg) {
212		t.Errorf("%q doesn't contain %q\n", barStr, panicMsg)
213		}
214		}
215
216		func TestBarPanicAfterComplete(t *testing.T) {
217		var buf bytes.Buffer
218		p := mpb.New(
219		mpb.WithWidth(80),
220		mpb.WithDebugOutput(&buf),
221		mpb.WithOutput(ioutil.Discard),
222		)
223
224		total := 100
225		panicMsg := "Upps!!!"
226		var pCount uint32
227		bar := p.AddBar(int64(total),
228		mpb.PrependDecorators(panicDecorator(panicMsg,
229		func(st decor.Statistics) bool {
230		if st.Completed {
231		atomic.AddUint32(&pCount, 1)
232		return true
233		}
234		return false
235		},
236		)),
237		)
238
239		for i := 0; i < total; i++ {
240		time.Sleep(10 * time.Millisecond)
241		bar.Increment()
242		}
243
244		p.Wait()
245
246		if pCount > 2 {
247		t.Error("Decor called after panic more than 2 times\n")
248		}
249
250		barStr := buf.String()
251		if !strings.Contains(barStr, panicMsg) {
252		t.Errorf("%q doesn't contain %q\n", barStr, panicMsg)
	223	t.Errorf("Want bar: %q:%d, got bar: %q:%d", wantBar, utf8.RuneCountInString(wantBar), got, utf8.RuneCountInString(got))
253	224	}
254	225	}
255	226
256	227	func TestDecorStatisticsAvailableWidth(t *testing.T) {
	228	ch := make(chan int, 2)
257	229	td1 := func(s decor.Statistics) string {
258		if s.AvailableWidth != 80 {
259		t.Errorf("expected AvailableWidth %d got %d\n", 80, s.AvailableWidth)
260		}
261		return fmt.Sprintf("\x1b[31;1;4m%s\x1b[0m", strings.Repeat("0", 20))
262		}
263		checkDone := make(chan struct{})
	230	ch <- s.AvailableWidth
	231	return strings.Repeat("0", 20)
	232	}
264	233	td2 := func(s decor.Statistics) string {
265		defer func() {
266		checkDone <- struct{}{}
267		}()
268		if s.AvailableWidth != 40 {
269		t.Errorf("expected AvailableWidth %d got %d\n", 40, s.AvailableWidth)
270		}
	234	ch <- s.AvailableWidth
271	235	return ""
272	236	}
273		total := 100
274		down := make(chan struct{})
275		p := mpb.New(
	237	ctx, cancel := context.WithCancel(context.Background())
	238	refresh := make(chan interface{})
	239	p := mpb.NewWithContext(ctx,
276	240	mpb.WithWidth(100),
277		mpb.WithShutdownNotifier(down),
278		mpb.WithOutput(ioutil.Discard),
279		)
280		bar := p.AddBar(int64(total),
	241	mpb.WithManualRefresh(refresh),
	242	mpb.WithOutput(io.Discard),
	243	)
	244	_ = p.AddBar(0,
281	245	mpb.BarFillerTrim(),
282	246	mpb.PrependDecorators(
283	247	decor.Name(strings.Repeat("0", 20)),
284		decor.Any(td1),
	248	decor.Meta(
	249	decor.Any(td1),
	250	func(s string) string {
	251	return "\x1b[31;1m" + s + "\x1b[0m"
	252	},
	253	),
285	254	),
286	255	mpb.AppendDecorators(
287	256	decor.Name(strings.Repeat("0", 20)),
288	257	decor.Any(td2),
289	258	),
290	259	)
	260	refresh <- time.Now()
291	261	go func() {
292		for {
293		select {
294		case <-checkDone:
295		bar.Abort(false)
296		case <-down:
297		return
298		}
299		}
	262	time.Sleep(10 * time.Millisecond)
	263	cancel()
300	264	}()
301		for !bar.Completed() {
302		bar.Increment()
303		}
304		p.Wait()
305		}
306
307		func panicDecorator(panicMsg string, cond func(decor.Statistics) bool) decor.Decorator {
308		return decor.Any(func(st decor.Statistics) string {
309		if cond(st) {
310		panic(panicMsg)
311		}
312		return ""
313		})
314		}
	265	p.Wait()
	266
	267	if availableWidth := <-ch; availableWidth != 80 {
	268	t.Errorf("expected AvailableWidth %d got %d", 80, availableWidth)
	269	}
	270
	271	if availableWidth := <-ch; availableWidth != 40 {
	272	t.Errorf("expected AvailableWidth %d got %d", 40, availableWidth)
	273	}
	274	}
	275
	276	func TestBarQueueAfterBar(t *testing.T) {
	277	shutdown := make(chan interface{})
	278	ctx, cancel := context.WithCancel(context.Background())
	279	p := mpb.NewWithContext(ctx,
	280	mpb.WithOutput(io.Discard),
	281	mpb.WithAutoRefresh(),
	282	mpb.WithShutdownNotifier(shutdown),
	283	)
	284	a := p.AddBar(100)
	285	b := p.AddBar(100, mpb.BarQueueAfter(a))
	286	identity := map[*mpb.Bar]string{
	287	a: "a",
	288	b: "b",
	289	}
	290
	291	a.IncrBy(100)
	292	a.Wait()
	293	cancel()
	294
	295	bars := (<-shutdown).([]*mpb.Bar)
	296	if l := len(bars); l != 1 {
	297	t.Errorf("Expected len of bars: %d, got: %d", 1, l)
	298	}
	299
	300	p.Wait()
	301	if bars[0] != b {
	302	t.Errorf("Expected bars[0] == b, got: %s", identity[bars[0]])
	303	}
	304	}

+83

-33

barbench_test.go less more

0		package mpb
	0	package mpb_test
1	1
2	2	import (
3		"io/ioutil"
	3	"io"
	4	"sync"
4	5	"testing"
5	6
6		"github.com/vbauerster/mpb/v7/decor"
	7	"github.com/vbauerster/mpb/v8"
7	8	)
8	9
9		func BenchmarkIncrSingleBar(b *testing.B) {
10		p := New(WithOutput(ioutil.Discard), WithWidth(80))
11		bar := p.AddBar(int64(b.N))
	10	const total = 1000
	11
	12	func BenchmarkNopStyle1Bar(b *testing.B) {
	13	bench(b, mpb.NopStyle(), false, 1)
	14	}
	15
	16	func BenchmarkNopStyle1BarWithAutoRefresh(b *testing.B) {
	17	bench(b, mpb.NopStyle(), true, 1)
	18	}
	19
	20	func BenchmarkNopStyle2Bars(b *testing.B) {
	21	bench(b, mpb.NopStyle(), false, 2)
	22	}
	23
	24	func BenchmarkNopStyle2BarsWithAutoRefresh(b *testing.B) {
	25	bench(b, mpb.NopStyle(), true, 2)
	26	}
	27
	28	func BenchmarkNopStyle3Bars(b *testing.B) {
	29	bench(b, mpb.NopStyle(), false, 3)
	30	}
	31
	32	func BenchmarkNopStyle3BarsWithAutoRefresh(b *testing.B) {
	33	bench(b, mpb.NopStyle(), true, 3)
	34	}
	35
	36	func BenchmarkBarStyle1Bar(b *testing.B) {
	37	bench(b, mpb.BarStyle(), false, 1)
	38	}
	39
	40	func BenchmarkBarStyle1BarWithAutoRefresh(b *testing.B) {
	41	bench(b, mpb.BarStyle(), true, 1)
	42	}
	43
	44	func BenchmarkBarStyle2Bars(b *testing.B) {
	45	bench(b, mpb.BarStyle(), false, 2)
	46	}
	47
	48	func BenchmarkBarStyle2BarsWithAutoRefresh(b *testing.B) {
	49	bench(b, mpb.BarStyle(), true, 2)
	50	}
	51
	52	func BenchmarkBarStyle3Bars(b *testing.B) {
	53	bench(b, mpb.BarStyle(), false, 3)
	54	}
	55
	56	func BenchmarkBarStyle3BarsWithAutoRefresh(b *testing.B) {
	57	bench(b, mpb.BarStyle(), true, 3)
	58	}
	59
	60	func bench(b *testing.B, builder mpb.BarFillerBuilder, autoRefresh bool, n int) {
	61	var wg sync.WaitGroup
	62	p := mpb.New(
	63	mpb.WithWidth(100),
	64	mpb.WithOutput(io.Discard),
	65	mpb.ContainerOptional(mpb.WithAutoRefresh(), autoRefresh),
	66	)
	67	b.ResetTimer()
12	68	for i := 0; i < b.N; i++ {
	69	for j := 0; j < n; j++ {
	70	bar := p.New(total, builder)
	71	switch j {
	72	case n - 1:
	73	complete(b, bar)
	74	default:
	75	wg.Add(1)
	76	go func() {
	77	complete(b, bar)
	78	wg.Done()
	79	}()
	80	}
	81	}
	82	wg.Wait()
	83	}
	84	p.Wait()
	85	}
	86
	87	func complete(b testing.B, bar mpb.Bar) {
	88	for i := 0; i < total; i++ {
13	89	bar.Increment()
14	90	}
	91	bar.Wait()
15	92	}
16
17		func BenchmarkIncrSingleBarWhileIsNotCompleted(b *testing.B) {
18		p := New(WithOutput(ioutil.Discard), WithWidth(80))
19		bar := p.AddBar(int64(b.N))
20		for !bar.Completed() {
21		bar.Increment()
22		}
23		}
24
25		func BenchmarkIncrSingleBarWithNameDecorator(b *testing.B) {
26		p := New(WithOutput(ioutil.Discard), WithWidth(80))
27		bar := p.AddBar(int64(b.N), PrependDecorators(decor.Name("test")))
28		for i := 0; i < b.N; i++ {
29		bar.Increment()
30		}
31		}
32
33		func BenchmarkIncrSingleBarWithNameAndEwmaETADecorator(b *testing.B) {
34		p := New(WithOutput(ioutil.Discard), WithWidth(80))
35		bar := p.AddBar(int64(b.N),
36		PrependDecorators(decor.Name("test")),
37		AppendDecorators(decor.EwmaETA(decor.ET_STYLE_GO, 60)),
38		)
39		for i := 0; i < b.N; i++ {
40		bar.Increment()
41		}
42		}

+48

-25

container_option.go less more

1	1
2	2	import (
3	3	"io"
4		"io/ioutil"
5	4	"sync"
6	5	"time"
7
8		"github.com/vbauerster/mpb/v7/internal"
9	6	)
10	7
11	8	// ContainerOption is a func option to alter default behavior of a bar

32	29	}
33	30	}
34	31
35		// WithRefreshRate overrides default 120ms refresh rate.
	32	// WithRefreshRate overrides default 150ms refresh rate.
36	33	func WithRefreshRate(d time.Duration) ContainerOption {
37	34	return func(s *pState) {
38		s.rr = d
	35	s.refreshRate = d
39	36	}
40	37	}
41	38

43	40	// Refresh will occur upon receive value from provided ch.
44	41	func WithManualRefresh(ch <-chan interface{}) ContainerOption {
45	42	return func(s *pState) {
46		s.externalRefresh = ch
	43	s.manualRC = ch
47	44	}
48	45	}
49	46

53	50	// rendering will start as soon as provided chan is closed.
54	51	func WithRenderDelay(ch <-chan struct{}) ContainerOption {
55	52	return func(s *pState) {
56		s.renderDelay = ch
	53	s.delayRC = ch
57	54	}
58	55	}
59	56
60		// WithShutdownNotifier provided chanel will be closed, after all bars
61		// have been rendered.
62		func WithShutdownNotifier(ch chan struct{}) ContainerOption {
	57	// WithShutdownNotifier value of type `[]*mpb.Bar` will be send into provided
	58	// channel upon container shutdown.
	59	func WithShutdownNotifier(ch chan<- interface{}) ContainerOption {
63	60	return func(s *pState) {
64	61	s.shutdownNotifier = ch
65	62	}
66	63	}
67	64
68		// WithOutput overrides default os.Stdout output. Setting it to nil
69		// will effectively disable auto refresh rate and discard any output,
70		// useful if you want to disable progress bars with little overhead.
	65	// WithOutput overrides default os.Stdout output. If underlying io.Writer
	66	// is not a terminal then auto refresh is disabled unless WithAutoRefresh
	67	// option is set.
71	68	func WithOutput(w io.Writer) ContainerOption {
	69	if w == nil {
	70	w = io.Discard
	71	}
72	72	return func(s *pState) {
73		if w == nil {
74		s.output = ioutil.Discard
75		s.outputDiscarded = true
76		return
77		}
78	73	s.output = w
79	74	}
80	75	}

82	77	// WithDebugOutput sets debug output.
83	78	func WithDebugOutput(w io.Writer) ContainerOption {
84	79	if w == nil {
85		return nil
	80	w = io.Discard
86	81	}
87	82	return func(s *pState) {
88	83	s.debugOut = w
89	84	}
90	85	}
91	86
92		// PopCompletedMode will pop and stop rendering completed bars.
	87	// WithAutoRefresh force auto refresh regardless of what output is set to.
	88	// Applicable only if not WithManualRefresh set.
	89	func WithAutoRefresh() ContainerOption {
	90	return func(s *pState) {
	91	s.autoRefresh = true
	92	}
	93	}
	94
	95	// PopCompletedMode will pop completed bars to the top.
	96	// To stop rendering bar after it has been popped, use
	97	// mpb.BarRemoveOnComplete() option on that bar.
93	98	func PopCompletedMode() ContainerOption {
94	99	return func(s *pState) {
95	100	s.popCompleted = true
96	101	}
97	102	}
98	103
99		// ContainerOptional will invoke provided option only when pick is true.
100		func ContainerOptional(option ContainerOption, pick bool) ContainerOption {
101		return ContainerOptOn(option, internal.Predicate(pick))
	104	// ContainerOptional will return provided option only when cond is true.
	105	func ContainerOptional(option ContainerOption, cond bool) ContainerOption {
	106	if cond {
	107	return option
	108	}
	109	return nil
102	110	}
103	111
104		// ContainerOptOn will invoke provided option only when higher order
105		// predicate evaluates to true.
	112	// ContainerOptOn will return provided option only when predicate evaluates to true.
106	113	func ContainerOptOn(option ContainerOption, predicate func() bool) ContainerOption {
107	114	if predicate() {
108	115	return option
109	116	}
110	117	return nil
111	118	}
	119
	120	// ContainerFuncOptional will call option and return its value only when cond is true.
	121	func ContainerFuncOptional(option func() ContainerOption, cond bool) ContainerOption {
	122	if cond {
	123	return option()
	124	}
	125	return nil
	126	}
	127
	128	// ContainerFuncOptOn will call option and return its value only when predicate evaluates to true.
	129	func ContainerFuncOptOn(option func() ContainerOption, predicate func() bool) ContainerOption {
	130	if predicate() {
	131	return option()
	132	}
	133	return nil
	134	}

+18

-12

cwriter/cuuAndEd_construction_bench_test.go less more

2	2	import (
3	3	"bytes"
4	4	"fmt"
5		"io/ioutil"
	5	"io"
6	6	"strconv"
7	7	"testing"
8	8	)
9	9
	10	var (
	11	out = io.Discard
	12	lines = 99
	13	)
	14
10	15	func BenchmarkWithFprintf(b *testing.B) {
11		cuuAndEd := "\x1b[%dA\x1b[J"
	16	verb := fmt.Sprintf("%s%%d%s", escOpen, cuuAndEd)
	17	b.ResetTimer()
12	18	for i := 0; i < b.N; i++ {
13		fmt.Fprintf(ioutil.Discard, cuuAndEd, 4)
	19	fmt.Fprintf(out, verb, lines)
14	20	}
15	21	}
16	22
17	23	func BenchmarkWithJoin(b *testing.B) {
18		bCuuAndEd := [][]byte{[]byte("\x1b["), []byte("A\x1b[J")}
	24	bCuuAndEd := [][]byte{[]byte(escOpen), []byte(cuuAndEd)}
19	25	for i := 0; i < b.N; i++ {
20		ioutil.Discard.Write(bytes.Join(bCuuAndEd, []byte(strconv.Itoa(4))))
	26	_, _ = out.Write(bytes.Join(bCuuAndEd, []byte(strconv.Itoa(lines))))
21	27	}
22	28	}
23	29
24	30	func BenchmarkWithAppend(b *testing.B) {
25		escOpen := []byte("\x1b[")
26		cuuAndEd := []byte("A\x1b[J")
	31	escOpen := []byte(escOpen)
	32	cuuAndEd := []byte(cuuAndEd)
27	33	for i := 0; i < b.N; i++ {
28		ioutil.Discard.Write(append(strconv.AppendInt(escOpen, 4, 10), cuuAndEd...))
	34	_, _ = out.Write(append(strconv.AppendInt(escOpen, int64(lines), 10), cuuAndEd...))
29	35	}
30	36	}
31	37
32		func BenchmarkWithCopy(b *testing.B) {
33		w := New(ioutil.Discard)
34		w.lineCount = 4
	38	func BenchmarkWithCurrentImpl(b *testing.B) {
	39	w := New(out)
	40	b.ResetTimer()
35	41	for i := 0; i < b.N; i++ {
36		w.ansiCuuAndEd()
	42	_ = w.ew.ansiCuuAndEd(out, lines)
37	43	}
38	44	}

+1

-1

cwriter/util_bsd.go less more

0		// +build darwin dragonfly freebsd netbsd openbsd
	0	//go:build darwin \|\| dragonfly \|\| freebsd \|\| netbsd \|\| openbsd
1	1
2	2	package cwriter
3	3

+1

-1

cwriter/util_linux.go less more

0		// +build aix linux
	0	//go:build aix \|\| linux
1	1
2	2	package cwriter
3	3

+1

-1

cwriter/util_solaris.go less more

0		// +build solaris
	0	//go:build solaris
1	1
2	2	package cwriter
3	3

+1

-1

cwriter/util_zos.go less more

0		// +build zos
	0	//go:build zos
1	1
2	2	package cwriter
3	3

+30

-55

cwriter/writer.go less more

7	7	"strconv"
8	8	)
9	9
10		// ErrNotTTY not a TeleTYpewriter error.
11		var ErrNotTTY = errors.New("not a terminal")
12
13		// http://ascii-table.com/ansi-escape-sequences.php
	10	// https://github.com/dylanaraps/pure-sh-bible#cursor-movement
14	11	const (
15	12	escOpen = "\x1b["
16	13	cuuAndEd = "A\x1b[J"
17	14	)
18	15
19		// Writer is a buffered the writer that updates the terminal. The
20		// contents of writer will be flushed when Flush is called.
21		type Writer struct {
22		out io.Writer
23		buf bytes.Buffer
24		lineCount int
25		fd int
26		isTerminal bool
27		}
	16	// ErrNotTTY not a TeleTYpewriter error.
	17	var ErrNotTTY = errors.New("not a terminal")
28	18
29	19	// New returns a new Writer with defaults.
30	20	func New(out io.Writer) *Writer {
31		w := &Writer{out: out}
	21	w := &Writer{
	22	Buffer: new(bytes.Buffer),
	23	out: out,
	24	termSize: func(_ int) (int, int, error) {
	25	return -1, -1, ErrNotTTY
	26	},
	27	}
32	28	if f, ok := out.(*os.File); ok {
33	29	w.fd = int(f.Fd())
34		w.isTerminal = IsTerminal(w.fd)
	30	if IsTerminal(w.fd) {
	31	w.terminal = true
	32	w.termSize = func(fd int) (int, int, error) {
	33	return GetSize(fd)
	34	}
	35	}
35	36	}
	37	bb := make([]byte, 16)
	38	w.ew = escWriter(bb[:copy(bb, []byte(escOpen))])
36	39	return w
37	40	}
38	41
39		// Flush flushes the underlying buffer.
40		func (w *Writer) Flush(lineCount int) (err error) {
41		// some terminals interpret 'cursor up 0' as 'cursor up 1'
42		if w.lineCount > 0 {
43		err = w.clearLines()
44		if err != nil {
45		return
46		}
47		}
48		w.lineCount = lineCount
49		_, err = w.buf.WriteTo(w.out)
50		return
	42	// IsTerminal tells whether underlying io.Writer is terminal.
	43	func (w *Writer) IsTerminal() bool {
	44	return w.terminal
51	45	}
52	46
53		// Write appends the contents of p to the underlying buffer.
54		func (w *Writer) Write(p []byte) (n int, err error) {
55		return w.buf.Write(p)
	47	// GetTermSize returns WxH of underlying terminal.
	48	func (w *Writer) GetTermSize() (width, height int, err error) {
	49	return w.termSize(w.fd)
56	50	}
57	51
58		// WriteString writes string to the underlying buffer.
59		func (w *Writer) WriteString(s string) (n int, err error) {
60		return w.buf.WriteString(s)
	52	type escWriter []byte
	53
	54	func (b escWriter) ansiCuuAndEd(out io.Writer, n int) error {
	55	b = strconv.AppendInt(b, int64(n), 10)
	56	_, err := out.Write(append(b, []byte(cuuAndEd)...))
	57	return err
61	58	}
62
63		// ReadFrom reads from the provided io.Reader and writes to the
64		// underlying buffer.
65		func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
66		return w.buf.ReadFrom(r)
67		}
68
69		// GetWidth returns width of underlying terminal.
70		func (w *Writer) GetWidth() (int, error) {
71		if !w.isTerminal {
72		return -1, ErrNotTTY
73		}
74		tw, _, err := GetSize(w.fd)
75		return tw, err
76		}
77
78		func (w *Writer) ansiCuuAndEd() (err error) {
79		buf := make([]byte, 8)
80		buf = strconv.AppendInt(buf[:copy(buf, escOpen)], int64(w.lineCount), 10)
81		_, err = w.out.Write(append(buf, cuuAndEd...))
82		return
83		}

+25

-3

cwriter/writer_posix.go less more

0		// +build !windows
	0	//go:build !windows
1	1
2	2	package cwriter
3	3
4	4	import (
	5	"bytes"
	6	"io"
	7
5	8	"golang.org/x/sys/unix"
6	9	)
7	10
8		func (w *Writer) clearLines() error {
9		return w.ansiCuuAndEd()
	11	// Writer is a buffered terminal writer, which moves cursor N lines up
	12	// on each flush except the first one, where N is a number of lines of
	13	// a previous flush.
	14	type Writer struct {
	15	*bytes.Buffer
	16	out io.Writer
	17	ew escWriter
	18	fd int
	19	terminal bool
	20	termSize func(int) (int, int, error)
	21	}
	22
	23	// Flush flushes the underlying buffer.
	24	// It's caller's responsibility to pass correct number of lines.
	25	func (w *Writer) Flush(lines int) error {
	26	_, err := w.WriteTo(w.out)
	27	// some terminals interpret 'cursor up 0' as 'cursor up 1'
	28	if err == nil && lines > 0 {
	29	err = w.ew.ansiCuuAndEd(w, lines)
	30	}
	31	return err
10	32	}
11	33
12	34	// GetSize returns the dimensions of the given terminal.

+35

-7

cwriter/writer_windows.go less more

0		// +build windows
	0	//go:build windows
1	1
2	2	package cwriter
3	3
4	4	import (
	5	"bytes"
	6	"io"
5	7	"unsafe"
6	8
7	9	"golang.org/x/sys/windows"

14	16	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
15	17	)
16	18
17		func (w *Writer) clearLines() error {
18		if !w.isTerminal {
	19	// Writer is a buffered terminal writer, which moves cursor N lines up
	20	// on each flush except the first one, where N is a number of lines of
	21	// a previous flush.
	22	type Writer struct {
	23	*bytes.Buffer
	24	out io.Writer
	25	ew escWriter
	26	lines int
	27	fd int
	28	terminal bool
	29	termSize func(int) (int, int, error)
	30	}
	31
	32	// Flush flushes the underlying buffer.
	33	// It's caller's responsibility to pass correct number of lines.
	34	func (w *Writer) Flush(lines int) error {
	35	if w.lines > 0 {
	36	err := w.clearLines(w.lines)
	37	if err != nil {
	38	return err
	39	}
	40	}
	41	w.lines = lines
	42	_, err := w.WriteTo(w.out)
	43	return err
	44	}
	45
	46	func (w *Writer) clearLines(n int) error {
	47	if !w.terminal {
19	48	// hope it's cygwin or similar
20		return w.ansiCuuAndEd()
	49	return w.ew.ansiCuuAndEd(w.out, n)
21	50	}
22	51
23	52	var info windows.ConsoleScreenBufferInfo

25	54	return err
26	55	}
27	56
28		info.CursorPosition.Y -= int16(w.lineCount)
	57	info.CursorPosition.Y -= int16(n)
29	58	if info.CursorPosition.Y < 0 {
30	59	info.CursorPosition.Y = 0
31	60	}

39	68	X: info.Window.Left,
40	69	Y: info.CursorPosition.Y,
41	70	}
42		count := uint32(info.Size.X) * uint32(w.lineCount)
	71	count := uint32(info.Size.X) * uint32(n)
43	72	_, _, _ = procFillConsoleOutputCharacter.Call(
44	73	uintptr(w.fd),
45	74	uintptr(' '),

51	80	}
52	81
53	82	// GetSize returns the visible dimensions of the given terminal.
54		//
55	83	// These dimensions don't include any scrollback buffer height.
56	84	func GetSize(fd int) (width, height int, err error) {
57	85	var info windows.ConsoleScreenBufferInfo

+7

-7

decor/any.go less more

0	0	package decor
1	1
2		// Any decorator displays text, that can be changed during decorator's
3		// lifetime via provided DecorFunc.
	2	var _ Decorator = any{}
	3
	4	// Any decorator.
	5	// Converts DecorFunc into Decorator.
4	6	//
5	7	// `fn` DecorFunc callback
6		//
7	8	// `wcc` optional WC config
8		//
9	9	func Any(fn DecorFunc, wcc ...WC) Decorator {
10		return &any{initWC(wcc...), fn}
	10	return any{initWC(wcc...), fn}
11	11	}
12	12
13	13	type any struct {

15	15	fn DecorFunc
16	16	}
17	17
18		func (d *any) Decor(s Statistics) string {
19		return d.FormatMsg(d.fn(s))
	18	func (d any) Decor(s Statistics) (string, int) {
	19	return d.Format(d.fn(s))
20	20	}

+110

-100

decor/counters.go less more

1	1
2	2	import (
3	3	"fmt"
4		"strings"
5		)
6
7		const (
8		_ = iota
9		UnitKiB
10		UnitKB
11	4	)
12	5
13	6	// CountersNoUnit is a wrapper around Counters with no unit param.

16	9	}
17	10
18	11	// CountersKibiByte is a wrapper around Counters with predefined unit
19		// UnitKiB (bytes/1024).
	12	// as SizeB1024(0).
20	13	func CountersKibiByte(pairFmt string, wcc ...WC) Decorator {
21		return Counters(UnitKiB, pairFmt, wcc...)
	14	return Counters(SizeB1024(0), pairFmt, wcc...)
22	15	}
23	16
24	17	// CountersKiloByte is a wrapper around Counters with predefined unit
25		// UnitKB (bytes/1000).
	18	// as SizeB1000(0).
26	19	func CountersKiloByte(pairFmt string, wcc ...WC) Decorator {
27		return Counters(UnitKB, pairFmt, wcc...)
	20	return Counters(SizeB1000(0), pairFmt, wcc...)
28	21	}
29	22
30	23	// Counters decorator with dynamic unit measure adjustment.
31	24	//
32		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
33		//
34		// `pairFmt` printf compatible verbs for current and total pair
35		//
36		// `wcc` optional WC config
37		//
38		// pairFmt example if unit=UnitKB:
39		//
	25	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
	26	//
	27	// `pairFmt` printf compatible verbs for current and total
	28	//
	29	// `wcc` optional WC config
	30	//
	31	// pairFmt example if unit=SizeB1000(0):
	32	//
	33	// pairFmt="%d / %d" output: "1MB / 12MB"
	34	// pairFmt="% d / % d" output: "1 MB / 12 MB"
40	35	// pairFmt="%.1f / %.1f" output: "1.0MB / 12.0MB"
41	36	// pairFmt="% .1f / % .1f" output: "1.0 MB / 12.0 MB"
42		// pairFmt="%d / %d" output: "1MB / 12MB"
43		// pairFmt="% d / % d" output: "1 MB / 12 MB"
44		//
45		func Counters(unit int, pairFmt string, wcc ...WC) Decorator {
46		producer := func(unit int, pairFmt string) DecorFunc {
47		if pairFmt == "" {
48		pairFmt = "%d / %d"
49		} else if strings.Count(pairFmt, "%") != 2 {
50		panic("expected pairFmt with exactly 2 verbs")
51		}
52		switch unit {
53		case UnitKiB:
	37	// pairFmt="%f / %f" output: "1.000000MB / 12.000000MB"
	38	// pairFmt="% f / % f" output: "1.000000 MB / 12.000000 MB"
	39	func Counters(unit interface{}, pairFmt string, wcc ...WC) Decorator {
	40	producer := func() DecorFunc {
	41	switch unit.(type) {
	42	case SizeB1024:
	43	if pairFmt == "" {
	44	pairFmt = "% d / % d"
	45	}
54	46	return func(s Statistics) string {
55	47	return fmt.Sprintf(pairFmt, SizeB1024(s.Current), SizeB1024(s.Total))
56	48	}
57		case UnitKB:
	49	case SizeB1000:
	50	if pairFmt == "" {
	51	pairFmt = "% d / % d"
	52	}
58	53	return func(s Statistics) string {
59	54	return fmt.Sprintf(pairFmt, SizeB1000(s.Current), SizeB1000(s.Total))
60	55	}
61	56	default:
	57	if pairFmt == "" {
	58	pairFmt = "%d / %d"
	59	}
62	60	return func(s Statistics) string {
63	61	return fmt.Sprintf(pairFmt, s.Current, s.Total)
64	62	}
65	63	}
66	64	}
67		return Any(producer(unit, pairFmt), wcc...)
	65	return Any(producer(), wcc...)
68	66	}
69	67
70	68	// TotalNoUnit is a wrapper around Total with no unit param.

73	71	}
74	72
75	73	// TotalKibiByte is a wrapper around Total with predefined unit
76		// UnitKiB (bytes/1024).
	74	// as SizeB1024(0).
77	75	func TotalKibiByte(format string, wcc ...WC) Decorator {
78		return Total(UnitKiB, format, wcc...)
	76	return Total(SizeB1024(0), format, wcc...)
79	77	}
80	78
81	79	// TotalKiloByte is a wrapper around Total with predefined unit
82		// UnitKB (bytes/1000).
	80	// as SizeB1000(0).
83	81	func TotalKiloByte(format string, wcc ...WC) Decorator {
84		return Total(UnitKB, format, wcc...)
	82	return Total(SizeB1000(0), format, wcc...)
85	83	}
86	84
87	85	// Total decorator with dynamic unit measure adjustment.
88	86	//
89		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	87	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
90	88	//
91	89	// `format` printf compatible verb for Total
92	90	//
93	91	// `wcc` optional WC config
94	92	//
95		// format example if unit=UnitKiB:
96		//
	93	// format example if unit=SizeB1024(0):
	94	//
	95	// format="%d" output: "12MiB"
	96	// format="% d" output: "12 MiB"
97	97	// format="%.1f" output: "12.0MiB"
98	98	// format="% .1f" output: "12.0 MiB"
99		// format="%d" output: "12MiB"
100		// format="% d" output: "12 MiB"
101		//
102		func Total(unit int, format string, wcc ...WC) Decorator {
103		producer := func(unit int, format string) DecorFunc {
104		if format == "" {
105		format = "%d"
106		} else if strings.Count(format, "%") != 1 {
107		panic("expected format with exactly 1 verb")
108		}
109
110		switch unit {
111		case UnitKiB:
	99	// format="%f" output: "12.000000MiB"
	100	// format="% f" output: "12.000000 MiB"
	101	func Total(unit interface{}, format string, wcc ...WC) Decorator {
	102	producer := func() DecorFunc {
	103	switch unit.(type) {
	104	case SizeB1024:
	105	if format == "" {
	106	format = "% d"
	107	}
112	108	return func(s Statistics) string {
113	109	return fmt.Sprintf(format, SizeB1024(s.Total))
114	110	}
115		case UnitKB:
	111	case SizeB1000:
	112	if format == "" {
	113	format = "% d"
	114	}
116	115	return func(s Statistics) string {
117	116	return fmt.Sprintf(format, SizeB1000(s.Total))
118	117	}
119	118	default:
	119	if format == "" {
	120	format = "%d"
	121	}
120	122	return func(s Statistics) string {
121	123	return fmt.Sprintf(format, s.Total)
122	124	}
123	125	}
124	126	}
125		return Any(producer(unit, format), wcc...)
	127	return Any(producer(), wcc...)
126	128	}
127	129
128	130	// CurrentNoUnit is a wrapper around Current with no unit param.

131	133	}
132	134
133	135	// CurrentKibiByte is a wrapper around Current with predefined unit
134		// UnitKiB (bytes/1024).
	136	// as SizeB1024(0).
135	137	func CurrentKibiByte(format string, wcc ...WC) Decorator {
136		return Current(UnitKiB, format, wcc...)
	138	return Current(SizeB1024(0), format, wcc...)
137	139	}
138	140
139	141	// CurrentKiloByte is a wrapper around Current with predefined unit
140		// UnitKB (bytes/1000).
	142	// as SizeB1000(0).
141	143	func CurrentKiloByte(format string, wcc ...WC) Decorator {
142		return Current(UnitKB, format, wcc...)
	144	return Current(SizeB1000(0), format, wcc...)
143	145	}
144	146
145	147	// Current decorator with dynamic unit measure adjustment.
146	148	//
147		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	149	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
148	150	//
149	151	// `format` printf compatible verb for Current
150	152	//
151	153	// `wcc` optional WC config
152	154	//
153		// format example if unit=UnitKiB:
154		//
	155	// format example if unit=SizeB1024(0):
	156	//
	157	// format="%d" output: "12MiB"
	158	// format="% d" output: "12 MiB"
155	159	// format="%.1f" output: "12.0MiB"
156	160	// format="% .1f" output: "12.0 MiB"
157		// format="%d" output: "12MiB"
158		// format="% d" output: "12 MiB"
159		//
160		func Current(unit int, format string, wcc ...WC) Decorator {
161		producer := func(unit int, format string) DecorFunc {
162		if format == "" {
163		format = "%d"
164		} else if strings.Count(format, "%") != 1 {
165		panic("expected format with exactly 1 verb")
166		}
167
168		switch unit {
169		case UnitKiB:
	161	// format="%f" output: "12.000000MiB"
	162	// format="% f" output: "12.000000 MiB"
	163	func Current(unit interface{}, format string, wcc ...WC) Decorator {
	164	producer := func() DecorFunc {
	165	switch unit.(type) {
	166	case SizeB1024:
	167	if format == "" {
	168	format = "% d"
	169	}
170	170	return func(s Statistics) string {
171	171	return fmt.Sprintf(format, SizeB1024(s.Current))
172	172	}
173		case UnitKB:
	173	case SizeB1000:
	174	if format == "" {
	175	format = "% d"
	176	}
174	177	return func(s Statistics) string {
175	178	return fmt.Sprintf(format, SizeB1000(s.Current))
176	179	}
177	180	default:
	181	if format == "" {
	182	format = "%d"
	183	}
178	184	return func(s Statistics) string {
179	185	return fmt.Sprintf(format, s.Current)
180	186	}
181	187	}
182	188	}
183		return Any(producer(unit, format), wcc...)
	189	return Any(producer(), wcc...)
184	190	}
185	191
186	192	// InvertedCurrentNoUnit is a wrapper around InvertedCurrent with no unit param.

189	195	}
190	196
191	197	// InvertedCurrentKibiByte is a wrapper around InvertedCurrent with predefined unit
192		// UnitKiB (bytes/1024).
	198	// as SizeB1024(0).
193	199	func InvertedCurrentKibiByte(format string, wcc ...WC) Decorator {
194		return InvertedCurrent(UnitKiB, format, wcc...)
	200	return InvertedCurrent(SizeB1024(0), format, wcc...)
195	201	}
196	202
197	203	// InvertedCurrentKiloByte is a wrapper around InvertedCurrent with predefined unit
198		// UnitKB (bytes/1000).
	204	// as SizeB1000(0).
199	205	func InvertedCurrentKiloByte(format string, wcc ...WC) Decorator {
200		return InvertedCurrent(UnitKB, format, wcc...)
	206	return InvertedCurrent(SizeB1000(0), format, wcc...)
201	207	}
202	208
203	209	// InvertedCurrent decorator with dynamic unit measure adjustment.
204	210	//
205		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	211	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
206	212	//
207	213	// `format` printf compatible verb for InvertedCurrent
208	214	//
209	215	// `wcc` optional WC config
210	216	//
211		// format example if unit=UnitKiB:
212		//
	217	// format example if unit=SizeB1024(0):
	218	//
	219	// format="%d" output: "12MiB"
	220	// format="% d" output: "12 MiB"
213	221	// format="%.1f" output: "12.0MiB"
214	222	// format="% .1f" output: "12.0 MiB"
215		// format="%d" output: "12MiB"
216		// format="% d" output: "12 MiB"
217		//
218		func InvertedCurrent(unit int, format string, wcc ...WC) Decorator {
219		producer := func(unit int, format string) DecorFunc {
220		if format == "" {
221		format = "%d"
222		} else if strings.Count(format, "%") != 1 {
223		panic("expected format with exactly 1 verb")
224		}
225
226		switch unit {
227		case UnitKiB:
	223	// format="%f" output: "12.000000MiB"
	224	// format="% f" output: "12.000000 MiB"
	225	func InvertedCurrent(unit interface{}, format string, wcc ...WC) Decorator {
	226	producer := func() DecorFunc {
	227	switch unit.(type) {
	228	case SizeB1024:
	229	if format == "" {
	230	format = "% d"
	231	}
228	232	return func(s Statistics) string {
229	233	return fmt.Sprintf(format, SizeB1024(s.Total-s.Current))
230	234	}
231		case UnitKB:
	235	case SizeB1000:
	236	if format == "" {
	237	format = "% d"
	238	}
232	239	return func(s Statistics) string {
233	240	return fmt.Sprintf(format, SizeB1000(s.Total-s.Current))
234	241	}
235	242	default:
	243	if format == "" {
	244	format = "%d"
	245	}
236	246	return func(s Statistics) string {
237	247	return fmt.Sprintf(format, s.Total-s.Current)
238	248	}
239	249	}
240	250	}
241		return Any(producer(unit, format), wcc...)
242		}
	251	return Any(producer(), wcc...)
	252	}

+33

-38

decor/decorator.go less more

3	3	"fmt"
4	4	"time"
5	5
6		"github.com/acarl005/stripansi"
7	6	"github.com/mattn/go-runewidth"
8	7	)
9	8
10	9	const (
11	10	// DidentRight bit specifies identation direction.
12		// \|foo \|b \| With DidentRight
13		// \| foo\| b\| Without DidentRight
	11	//
	12	// \|foo \|b \| With DidentRight
	13	// \| foo\| b\| Without DidentRight
14	14	DidentRight = 1 << iota
15	15
16	16	// DextraSpace bit adds extra space, makes sense with DSyncWidth only.

43	43	ET_STYLE_MMSS
44	44	)
45	45
46		// Statistics consists of progress related statistics, that Decorator
47		// may need.
	46	// Statistics contains fields which are necessary for implementing
	47	// `decor.Decorator` and `mpb.BarFiller` interfaces.
48	48	type Statistics struct {
	49	AvailableWidth int // calculated width initially equal to terminal width
	50	RequestedWidth int // width set by `mpb.WithWidth`
49	51	ID int
50		AvailableWidth int
51	52	Total int64
52	53	Current int64
53	54	Refill int64
54	55	Completed bool
	56	Aborted bool
55	57	}
56	58
57	59	// Decorator interface.

63	65	// `DecorFunc` into a `Decorator` interface by using provided
64	66	// `func Any(DecorFunc, ...WC) Decorator`.
65	67	type Decorator interface {
66		Configurator
67	68	Synchronizer
68		Decor(Statistics) string
	69	Formatter
	70	Decor(Statistics) (str string, viewWidth int)
69	71	}
70	72
71	73	// DecorFunc func type.
72		// To be used with `func Any`(DecorFunc, ...WC) Decorator`.
	74	// To be used with `func Any(DecorFunc, ...WC) Decorator`.
73	75	type DecorFunc func(Statistics) string
74	76
75	77	// Synchronizer interface.

79	81	Sync() (chan int, bool)
80	82	}
81	83
82		// Configurator interface.
83		type Configurator interface {
84		GetConf() WC
85		SetConf(WC)
	84	// Formatter interface.
	85	// Format method needs to be called from within Decorator.Decor method
	86	// in order to format string according to decor.WC settings.
	87	// No need to implement manually as long as decor.WC is embedded.
	88	type Formatter interface {
	89	Format(string) (str string, viewWidth int)
86	90	}
87	91
88	92	// Wrapper interface.

90	94	// it is necessary to implement this interface to retain functionality
91	95	// of built-in Decorator.
92	96	type Wrapper interface {
93		Base() Decorator
	97	Unwrap() Decorator
94	98	}
95	99
96	100	// EwmaDecorator interface.

110	114	// If decorator needs to be notified once upon bar shutdown event, so
111	115	// this is the right interface to implement.
112	116	type ShutdownListener interface {
113		Shutdown()
	117	OnShutdown()
114	118	}
115	119
116	120	// Global convenience instances of WC with sync width bit set.

132	136	wsync chan int
133	137	}
134	138
135		// FormatMsg formats final message according to WC.W and WC.C.
136		// Should be called by any Decorator implementation.
137		func (wc *WC) FormatMsg(msg string) string {
138		pureWidth := runewidth.StringWidth(msg)
139		stripWidth := runewidth.StringWidth(stripansi.Strip(msg))
140		maxCell := wc.W
	139	// Format should be called by any Decorator implementation.
	140	// Returns formatted string and its view (visual) width.
	141	func (wc WC) Format(str string) (string, int) {
	142	viewWidth := runewidth.StringWidth(str)
	143	if wc.W > viewWidth {
	144	viewWidth = wc.W
	145	}
141	146	if (wc.C & DSyncWidth) != 0 {
142		cellCount := stripWidth
143	147	if (wc.C & DextraSpace) != 0 {
144		cellCount++
	148	viewWidth++
145	149	}
146		wc.wsync <- cellCount
147		maxCell = <-wc.wsync
	150	wc.wsync <- viewWidth
	151	viewWidth = <-wc.wsync
148	152	}
149		return wc.fill(msg, maxCell+(pureWidth-stripWidth))
	153	return wc.fill(str, viewWidth), viewWidth
150	154	}
151	155
152	156	// Init initializes width related config.
153	157	func (wc *WC) Init() WC {
154		wc.fill = runewidth.FillLeft
155	158	if (wc.C & DidentRight) != 0 {
156	159	wc.fill = runewidth.FillRight
	160	} else {
	161	wc.fill = runewidth.FillLeft
157	162	}
158	163	if (wc.C & DSyncWidth) != 0 {
159	164	// it's deliberate choice to override wsync on each Init() call,

164	169	}
165	170
166	171	// Sync is implementation of Synchronizer interface.
167		func (wc *WC) Sync() (chan int, bool) {
	172	func (wc WC) Sync() (chan int, bool) {
168	173	if (wc.C&DSyncWidth) != 0 && wc.wsync == nil {
169	174	panic(fmt.Sprintf("%T is not initialized", wc))
170	175	}
171	176	return wc.wsync, (wc.C & DSyncWidth) != 0
172		}
173
174		// GetConf is implementation of Configurator interface.
175		func (wc *WC) GetConf() WC {
176		return *wc
177		}
178
179		// SetConf is implementation of Configurator interface.
180		func (wc *WC) SetConf(conf WC) {
181		*wc = conf.Init()
182	177	}
183	178
184	179	func initWC(wcc ...WC) WC {

+5

-5

decor/doc.go less more

0		// Package decor provides common decorators for "github.com/vbauerster/mpb/v7" module.
	0	// Package decor provides common decorators for "github.com/vbauerster/mpb/v8" module.
1	1	//
2	2	// Some decorators returned by this package might have a closure state. It is ok to use
3	3	// decorators concurrently, unless you share the same decorator among multiple

5	5	//
6	6	// Don't:
7	7	//
8		// p := mpb.New()
9		// name := decor.Name("bar")
10		// p.AddBar(100, mpb.AppendDecorators(name))
11		// p.AddBar(100, mpb.AppendDecorators(name))
	8	// p := mpb.New()
	9	// name := decor.Name("bar")
	10	// p.AddBar(100, mpb.AppendDecorators(name))
	11	// p.AddBar(100, mpb.AppendDecorators(name))
12	12	//
13	13	// Do:
14	14	//

+0

-2

decor/elapsed.go less more

8	8	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
9	9	//
10	10	// `wcc` optional WC config
11		//
12	11	func Elapsed(style TimeStyle, wcc ...WC) Decorator {
13	12	return NewElapsed(style, time.Now(), wcc...)
14	13	}

20	19	// `startTime` start time
21	20	//
22	21	// `wcc` optional WC config
23		//
24	22	func NewElapsed(style TimeStyle, startTime time.Time, wcc ...WC) Decorator {
25	23	var msg string
26	24	producer := chooseTimeProducer(style)

+18

-16

decor/eta.go less more

7	7	"github.com/VividCortex/ewma"
8	8	)
9	9
	10	var (
	11	_ Decorator = (*movingAverageETA)(nil)
	12	_ EwmaDecorator = (*movingAverageETA)(nil)
	13	_ Decorator = (*averageETA)(nil)
	14	_ AverageDecorator = (*averageETA)(nil)
	15	)
	16
10	17	// TimeNormalizer interface. Implementors could be passed into
11	18	// MovingAverageETA, in order to affect i.e. normalize its output.
12	19	type TimeNormalizer interface {

21	28	return f(src)
22	29	}
23	30
24		// EwmaETA exponential-weighted-moving-average based ETA decorator.
25		// For this decorator to work correctly you have to measure each
26		// iteration's duration and pass it to the
27		// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
	31	// EwmaETA exponential-weighted-moving-average based ETA decorator. For this
	32	// decorator to work correctly you have to measure each iteration's duration
	33	// and pass it to one of the (*Bar).EwmaIncr... family methods.
28	34	func EwmaETA(style TimeStyle, age float64, wcc ...WC) Decorator {
29	35	var average ewma.MovingAverage
30	36	if age == 0 {

44	50	// `normalizer` available implementations are [FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
45	51	//
46	52	// `wcc` optional WC config
47		//
48	53	func MovingAverageETA(style TimeStyle, average ewma.MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
49	54	d := &movingAverageETA{
50	55	WC: initWC(wcc...),

62	67	producer func(time.Duration) string
63	68	}
64	69
65		func (d *movingAverageETA) Decor(s Statistics) string {
	70	func (d *movingAverageETA) Decor(s Statistics) (string, int) {
66	71	v := math.Round(d.average.Value())
67	72	remaining := time.Duration((s.Total - s.Current) * int64(v))
68	73	if d.normalizer != nil {
69	74	remaining = d.normalizer.Normalize(remaining)
70	75	}
71		return d.FormatMsg(d.producer(remaining))
	76	return d.Format(d.producer(remaining))
72	77	}
73	78
74	79	func (d *movingAverageETA) EwmaUpdate(n int64, dur time.Duration) {

84	89	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
85	90	//
86	91	// `wcc` optional WC config
87		//
88	92	func AverageETA(style TimeStyle, wcc ...WC) Decorator {
89	93	return NewAverageETA(style, time.Now(), nil, wcc...)
90	94	}

98	102	// `normalizer` available implementations are [FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
99	103	//
100	104	// `wcc` optional WC config
101		//
102	105	func NewAverageETA(style TimeStyle, startTime time.Time, normalizer TimeNormalizer, wcc ...WC) Decorator {
103	106	d := &averageETA{
104	107	WC: initWC(wcc...),

116	119	producer func(time.Duration) string
117	120	}
118	121
119		func (d *averageETA) Decor(s Statistics) string {
	122	func (d *averageETA) Decor(s Statistics) (string, int) {
120	123	var remaining time.Duration
121	124	if s.Current != 0 {
122	125	durPerItem := float64(time.Since(d.startTime)) / float64(s.Current)

126	129	remaining = d.normalizer.Normalize(remaining)
127	130	}
128	131	}
129		return d.FormatMsg(d.producer(remaining))
	132	return d.Format(d.producer(remaining))
130	133	}
131	134
132	135	func (d *averageETA) AverageAdjust(startTime time.Time) {

195	198	}
196	199	default:
197	200	return func(remaining time.Duration) string {
198		// strip off nanoseconds
199		return ((remaining / time.Second) * time.Second).String()
200		}
201		}
202		}
	201	return remaining.Truncate(time.Second).String()
	202	}
	203	}
	204	}

+0

-107

~~decor/merge.go~~ less more

0		package decor
1
2		import (
3		"strings"
4
5		"github.com/acarl005/stripansi"
6		"github.com/mattn/go-runewidth"
7		)
8
9		// Merge wraps its decorator argument with intention to sync width
10		// with several decorators of another bar. Visual example:
11		//
12		// +----+--------+---------+--------+
13		// \| B1 \| MERGE(D, P1, Pn) \|
14		// +----+--------+---------+--------+
15		// \| B2 \| D0 \| D1 \| Dn \|
16		// +----+--------+---------+--------+
17		//
18		func Merge(decorator Decorator, placeholders ...WC) Decorator {
19		if _, ok := decorator.Sync(); !ok \|\| len(placeholders) == 0 {
20		return decorator
21		}
22		md := &mergeDecorator{
23		Decorator: decorator,
24		wc: decorator.GetConf(),
25		placeHolders: make([]*placeHolderDecorator, len(placeholders)),
26		}
27		decorator.SetConf(WC{})
28		for i, wc := range placeholders {
29		if (wc.C & DSyncWidth) == 0 {
30		return decorator
31		}
32		md.placeHolders[i] = &placeHolderDecorator{wc.Init()}
33		}
34		return md
35		}
36
37		type mergeDecorator struct {
38		Decorator
39		wc WC
40		placeHolders []*placeHolderDecorator
41		}
42
43		func (d *mergeDecorator) GetConf() WC {
44		return d.wc
45		}
46
47		func (d *mergeDecorator) SetConf(conf WC) {
48		d.wc = conf.Init()
49		}
50
51		func (d *mergeDecorator) MergeUnwrap() []Decorator {
52		decorators := make([]Decorator, len(d.placeHolders))
53		for i, ph := range d.placeHolders {
54		decorators[i] = ph
55		}
56		return decorators
57		}
58
59		func (d *mergeDecorator) Sync() (chan int, bool) {
60		return d.wc.Sync()
61		}
62
63		func (d *mergeDecorator) Base() Decorator {
64		return d.Decorator
65		}
66
67		func (d *mergeDecorator) Decor(s Statistics) string {
68		msg := d.Decorator.Decor(s)
69		pureWidth := runewidth.StringWidth(msg)
70		stripWidth := runewidth.StringWidth(stripansi.Strip(msg))
71		cellCount := stripWidth
72		if (d.wc.C & DextraSpace) != 0 {
73		cellCount++
74		}
75
76		total := runewidth.StringWidth(d.placeHolders[0].FormatMsg(""))
77		pw := (cellCount - total) / len(d.placeHolders)
78		rem := (cellCount - total) % len(d.placeHolders)
79
80		var diff int
81		for i := 1; i < len(d.placeHolders); i++ {
82		ph := d.placeHolders[i]
83		width := pw - diff
84		if (ph.WC.C & DextraSpace) != 0 {
85		width--
86		if width < 0 {
87		width = 0
88		}
89		}
90		max := runewidth.StringWidth(ph.FormatMsg(strings.Repeat(" ", width)))
91		total += max
92		diff = max - pw
93		}
94
95		d.wc.wsync <- pw + rem
96		max := <-d.wc.wsync
97		return d.wc.fill(msg, max+total+(pureWidth-stripWidth))
98		}
99
100		type placeHolderDecorator struct {
101		WC
102		}
103
104		func (d *placeHolderDecorator) Decor(Statistics) string {
105		return ""
106		}

+34

-0

decor/meta.go less more

	0	package decor
	1
	2	var (
	3	_ Decorator = metaWrapper{}
	4	_ Wrapper = metaWrapper{}
	5	)
	6
	7	// Meta wrap decorator.
	8	// Provided fn is supposed to wrap output of given decorator
	9	// with meta information like ANSI escape codes for example.
	10	// Primary usage intention is to set SGR display attributes.
	11	//
	12	// `decorator` Decorator to wrap
	13	// `fn` func to apply meta information
	14	func Meta(decorator Decorator, fn func(string) string) Decorator {
	15	if decorator == nil {
	16	return nil
	17	}
	18	return metaWrapper{decorator, fn}
	19	}
	20
	21	type metaWrapper struct {
	22	Decorator
	23	fn func(string) string
	24	}
	25
	26	func (d metaWrapper) Decor(s Statistics) (string, int) {
	27	str, width := d.Decorator.Decor(s)
	28	return d.fn(str), width
	29	}
	30
	31	func (d metaWrapper) Unwrap() Decorator {
	32	return d.Decorator
	33	}

+6

-0

decor/moving_average.go less more

4	4	"sync"
5	5
6	6	"github.com/VividCortex/ewma"
	7	)
	8
	9	var (
	10	_ ewma.MovingAverage = (*threadSafeMovingAverage)(nil)
	11	_ ewma.MovingAverage = (*medianWindow)(nil)
	12	_ sort.Interface = (*medianWindow)(nil)
7	13	)
8	14
9	15	type threadSafeMovingAverage struct {

+0

-1

decor/name.go less more

5	5	// `str` string to display
6	6	//
7	7	// `wcc` optional WC config
8		//
9	8	func Name(str string, wcc ...WC) Decorator {
10	9	return Any(func(Statistics) string { return str }, wcc...)
11	10	}

+68

-0

decor/on_abort.go less more

	0	package decor
	1
	2	var (
	3	_ Decorator = onAbortWrapper{}
	4	_ Wrapper = onAbortWrapper{}
	5	_ Decorator = onAbortMetaWrapper{}
	6	_ Wrapper = onAbortMetaWrapper{}
	7	)
	8
	9	// OnAbort wrap decorator.
	10	// Displays provided message on abort event.
	11	// Has no effect if bar.Abort(true) is called.
	12	//
	13	// `decorator` Decorator to wrap
	14	// `message` message to display
	15	func OnAbort(decorator Decorator, message string) Decorator {
	16	if decorator == nil {
	17	return nil
	18	}
	19	return onAbortWrapper{decorator, message}
	20	}
	21
	22	type onAbortWrapper struct {
	23	Decorator
	24	msg string
	25	}
	26
	27	func (d onAbortWrapper) Decor(s Statistics) (string, int) {
	28	if s.Aborted {
	29	return d.Format(d.msg)
	30	}
	31	return d.Decorator.Decor(s)
	32	}
	33
	34	func (d onAbortWrapper) Unwrap() Decorator {
	35	return d.Decorator
	36	}
	37
	38	// OnAbortMeta wrap decorator.
	39	// Provided fn is supposed to wrap output of given decorator
	40	// with meta information like ANSI escape codes for example.
	41	// Primary usage intention is to set SGR display attributes.
	42	//
	43	// `decorator` Decorator to wrap
	44	// `fn` func to apply meta information
	45	func OnAbortMeta(decorator Decorator, fn func(string) string) Decorator {
	46	if decorator == nil {
	47	return nil
	48	}
	49	return onAbortMetaWrapper{decorator, fn}
	50	}
	51
	52	type onAbortMetaWrapper struct {
	53	Decorator
	54	fn func(string) string
	55	}
	56
	57	func (d onAbortMetaWrapper) Decor(s Statistics) (string, int) {
	58	if s.Completed {
	59	str, width := d.Decorator.Decor(s)
	60	return d.fn(str), width
	61	}
	62	return d.Decorator.Decor(s)
	63	}
	64
	65	func (d onAbortMetaWrapper) Unwrap() Decorator {
	66	return d.Decorator
	67	}

+21

-0

decor/on_compete_or_on_abort.go less more

	0	package decor
	1
	2	// OnCompleteOrOnAbort wrap decorator.
	3	// Displays provided message on complete or on abort event.
	4	//
	5	// `decorator` Decorator to wrap
	6	// `message` message to display
	7	func OnCompleteOrOnAbort(decorator Decorator, message string) Decorator {
	8	return OnComplete(OnAbort(decorator, message), message)
	9	}
	10
	11	// OnCompleteMetaOrOnAbortMeta wrap decorator.
	12	// Provided fn is supposed to wrap output of given decorator
	13	// with meta information like ANSI escape codes for example.
	14	// Primary usage intention is to set SGR display attributes.
	15	//
	16	// `decorator` Decorator to wrap
	17	// `fn` func to apply meta information
	18	func OnCompleteMetaOrOnAbortMeta(decorator Decorator, fn func(string) string) Decorator {
	19	return OnCompleteMeta(OnAbortMeta(decorator, fn), fn)
	20	}

+47

-17

decor/on_complete.go less more

0	0	package decor
1	1
2		// OnComplete returns decorator, which wraps provided decorator, with
3		// sole purpose to display provided message on complete event.
	2	var (
	3	_ Decorator = onCompleteWrapper{}
	4	_ Wrapper = onCompleteWrapper{}
	5	_ Decorator = onCompleteMetaWrapper{}
	6	_ Wrapper = onCompleteMetaWrapper{}
	7	)
	8
	9	// OnComplete wrap decorator.
	10	// Displays provided message on complete event.
4	11	//
5	12	// `decorator` Decorator to wrap
6		//
7		// `message` message to display on complete event
8		//
	13	// `message` message to display
9	14	func OnComplete(decorator Decorator, message string) Decorator {
10		d := &onCompleteWrapper{
11		Decorator: decorator,
12		msg: message,
	15	if decorator == nil {
	16	return nil
13	17	}
14		if md, ok := decorator.(*mergeDecorator); ok {
15		d.Decorator, md.Decorator = md.Decorator, d
16		return md
17		}
18		return d
	18	return onCompleteWrapper{decorator, message}
19	19	}
20	20
21	21	type onCompleteWrapper struct {

23	23	msg string
24	24	}
25	25
26		func (d *onCompleteWrapper) Decor(s Statistics) string {
	26	func (d onCompleteWrapper) Decor(s Statistics) (string, int) {
27	27	if s.Completed {
28		wc := d.GetConf()
29		return wc.FormatMsg(d.msg)
	28	return d.Format(d.msg)
30	29	}
31	30	return d.Decorator.Decor(s)
32	31	}
33	32
34		func (d *onCompleteWrapper) Base() Decorator {
	33	func (d onCompleteWrapper) Unwrap() Decorator {
35	34	return d.Decorator
36	35	}
	36
	37	// OnCompleteMeta wrap decorator.
	38	// Provided fn is supposed to wrap output of given decorator
	39	// with meta information like ANSI escape codes for example.
	40	// Primary usage intention is to set SGR display attributes.
	41	//
	42	// `decorator` Decorator to wrap
	43	// `fn` func to apply meta information
	44	func OnCompleteMeta(decorator Decorator, fn func(string) string) Decorator {
	45	if decorator == nil {
	46	return nil
	47	}
	48	return onCompleteMetaWrapper{decorator, fn}
	49	}
	50
	51	type onCompleteMetaWrapper struct {
	52	Decorator
	53	fn func(string) string
	54	}
	55
	56	func (d onCompleteMetaWrapper) Decor(s Statistics) (string, int) {
	57	if s.Completed {
	58	str, width := d.Decorator.Decor(s)
	59	return d.fn(str), width
	60	}
	61	return d.Decorator.Decor(s)
	62	}
	63
	64	func (d onCompleteMetaWrapper) Unwrap() Decorator {
	65	return d.Decorator
	66	}

+51

-0

decor/on_condition.go less more

	0	package decor
	1
	2	// OnCondition applies decorator only if a condition is true.
	3	//
	4	// `decorator` Decorator
	5	//
	6	// `cond` bool
	7	func OnCondition(decorator Decorator, cond bool) Decorator {
	8	return Conditional(cond, decorator, nil)
	9	}
	10
	11	// OnPredicate applies decorator only if a predicate evaluates to true.
	12	//
	13	// `decorator` Decorator
	14	//
	15	// `predicate` func() bool
	16	func OnPredicate(decorator Decorator, predicate func() bool) Decorator {
	17	return Predicative(predicate, decorator, nil)
	18	}
	19
	20	// Conditional returns decorator `a` if condition is true, otherwise
	21	// decorator `b`.
	22	//
	23	// `cond` bool
	24	//
	25	// `a` Decorator
	26	//
	27	// `b` Decorator
	28	func Conditional(cond bool, a, b Decorator) Decorator {
	29	if cond {
	30	return a
	31	} else {
	32	return b
	33	}
	34	}
	35
	36	// Predicative returns decorator `a` if predicate evaluates to true,
	37	// otherwise decorator `b`.
	38	//
	39	// `predicate` func() bool
	40	//
	41	// `a` Decorator
	42	//
	43	// `b` Decorator
	44	func Predicative(predicate func() bool, a, b Decorator) Decorator {
	45	if predicate() {
	46	return a
	47	} else {
	48	return b
	49	}
	50	}

+26

-16

decor/percentage.go less more

1	1
2	2	import (
3	3	"fmt"
4		"io"
5	4	"strconv"
6	5
7		"github.com/vbauerster/mpb/v7/internal"
	6	"github.com/vbauerster/mpb/v8/internal"
8	7	)
	8
	9	var _ fmt.Formatter = percentageType(0)
9	10
10	11	type percentageType float64
11	12
12	13	func (s percentageType) Format(st fmt.State, verb rune) {
13		var prec int
	14	prec := -1
14	15	switch verb {
15		case 'd':
16		case 's':
17		prec = -1
18		default:
	16	case 'f', 'e', 'E':
	17	prec = 6 // default prec of fmt.Printf("%f\|%e\|%E")
	18	fallthrough
	19	case 'b', 'g', 'G', 'x', 'X':
19	20	if p, ok := st.Precision(); ok {
20	21	prec = p
21		} else {
22		prec = 6
23	22	}
	23	default:
	24	verb, prec = 'f', 0
24	25	}
25	26
26		io.WriteString(st, strconv.FormatFloat(float64(s), 'f', prec, 64))
27
	27	b := strconv.AppendFloat(make([]byte, 0, 16), float64(s), byte(verb), prec, 64)
28	28	if st.Flag(' ') {
29		io.WriteString(st, " ")
	29	b = append(b, ' ', '%')
	30	} else {
	31	b = append(b, '%')
30	32	}
31		io.WriteString(st, "%")
	33	_, err := st.Write(b)
	34	if err != nil {
	35	panic(err)
	36	}
32	37	}
33	38
34	39	// Percentage returns percentage decorator. It's a wrapper of NewPercentage.

38	43
39	44	// NewPercentage percentage decorator with custom format string.
40	45	//
	46	// `format` printf compatible verb
	47	//
	48	// `wcc` optional WC config
	49	//
41	50	// format examples:
42	51	//
	52	// format="%d" output: "1%"
	53	// format="% d" output: "1 %"
43	54	// format="%.1f" output: "1.0%"
44	55	// format="% .1f" output: "1.0 %"
45		// format="%d" output: "1%"
46		// format="% d" output: "1 %"
47		//
	56	// format="%f" output: "1.000000%"
	57	// format="% f" output: "1.000000 %"
48	58	func NewPercentage(format string, wcc ...WC) Decorator {
49	59	if format == "" {
50	60	format = "% d"

+58

-0

decor/percentage_test.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"testing"
	5	)
	6
	7	func TestPercentageType(t *testing.T) {
	8	cases := map[string]struct {
	9	value float64
	10	verb string
	11	expected string
	12	}{
	13	"10 %d": {10, "%d", "10%"},
	14	"10 %s": {10, "%s", "10%"},
	15	"10 %f": {10, "%f", "10.000000%"},
	16	"10 %.6f": {10, "%.6f", "10.000000%"},
	17	"10 %.0f": {10, "%.0f", "10%"},
	18	"10 %.1f": {10, "%.1f", "10.0%"},
	19	"10 %.2f": {10, "%.2f", "10.00%"},
	20	"10 %.3f": {10, "%.3f", "10.000%"},
	21
	22	"10 % d": {10, "% d", "10 %"},
	23	"10 % s": {10, "% s", "10 %"},
	24	"10 % f": {10, "% f", "10.000000 %"},
	25	"10 % .6f": {10, "% .6f", "10.000000 %"},
	26	"10 % .0f": {10, "% .0f", "10 %"},
	27	"10 % .1f": {10, "% .1f", "10.0 %"},
	28	"10 % .2f": {10, "% .2f", "10.00 %"},
	29	"10 % .3f": {10, "% .3f", "10.000 %"},
	30
	31	"10.5 %d": {10.5, "%d", "10%"},
	32	"10.5 %s": {10.5, "%s", "10%"},
	33	"10.5 %f": {10.5, "%f", "10.500000%"},
	34	"10.5 %.6f": {10.5, "%.6f", "10.500000%"},
	35	"10.5 %.0f": {10.5, "%.0f", "10%"},
	36	"10.5 %.1f": {10.5, "%.1f", "10.5%"},
	37	"10.5 %.2f": {10.5, "%.2f", "10.50%"},
	38	"10.5 %.3f": {10.5, "%.3f", "10.500%"},
	39
	40	"10.5 % d": {10.5, "% d", "10 %"},
	41	"10.5 % s": {10.5, "% s", "10 %"},
	42	"10.5 % f": {10.5, "% f", "10.500000 %"},
	43	"10.5 % .6f": {10.5, "% .6f", "10.500000 %"},
	44	"10.5 % .0f": {10.5, "% .0f", "10 %"},
	45	"10.5 % .1f": {10.5, "% .1f", "10.5 %"},
	46	"10.5 % .2f": {10.5, "% .2f", "10.50 %"},
	47	"10.5 % .3f": {10.5, "% .3f", "10.500 %"},
	48	}
	49	for name, tc := range cases {
	50	t.Run(name, func(t *testing.T) {
	51	got := fmt.Sprintf(tc.verb, percentageType(tc.value))
	52	if got != tc.expected {
	53	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	54	}
	55	})
	56	}
	57	}

+37

-26

decor/size_type.go less more

1	1
2	2	import (
3	3	"fmt"
4		"io"
5		"math"
6	4	"strconv"
7	5	)
8	6
9	7	//go:generate stringer -type=SizeB1024 -trimprefix=_i
10	8	//go:generate stringer -type=SizeB1000 -trimprefix=_
	9
	10	var (
	11	_ fmt.Formatter = SizeB1024(0)
	12	_ fmt.Stringer = SizeB1024(0)
	13	_ fmt.Formatter = SizeB1000(0)
	14	_ fmt.Stringer = SizeB1000(0)
	15	)
11	16
12	17	const (
13	18	_ib SizeB1024 = iota + 1

23	28	type SizeB1024 int64
24	29
25	30	func (self SizeB1024) Format(st fmt.State, verb rune) {
26		var prec int
	31	prec := -1
27	32	switch verb {
28		case 'd':
29		case 's':
30		prec = -1
31		default:
	33	case 'f', 'e', 'E':
	34	prec = 6 // default prec of fmt.Printf("%f\|%e\|%E")
	35	fallthrough
	36	case 'b', 'g', 'G', 'x', 'X':
32	37	if p, ok := st.Precision(); ok {
33	38	prec = p
34		} else {
35		prec = 6
36	39	}
	40	default:
	41	verb, prec = 'f', 0
37	42	}
38	43
39	44	var unit SizeB1024

46	51	unit = _iMiB
47	52	case self < _iTiB:
48	53	unit = _iGiB
49		case self <= math.MaxInt64:
	54	default:
50	55	unit = _iTiB
51	56	}
52	57
53		io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
54
	58	b := strconv.AppendFloat(make([]byte, 0, 24), float64(self)/float64(unit), byte(verb), prec, 64)
55	59	if st.Flag(' ') {
56		io.WriteString(st, " ")
	60	b = append(b, ' ')
57	61	}
58		io.WriteString(st, unit.String())
	62	b = append(b, []byte(unit.String())...)
	63	_, err := st.Write(b)
	64	if err != nil {
	65	panic(err)
	66	}
59	67	}
60	68
61	69	const (

72	80	type SizeB1000 int64
73	81
74	82	func (self SizeB1000) Format(st fmt.State, verb rune) {
75		var prec int
	83	prec := -1
76	84	switch verb {
77		case 'd':
78		case 's':
79		prec = -1
80		default:
	85	case 'f', 'e', 'E':
	86	prec = 6 // default prec of fmt.Printf("%f\|%e\|%E")
	87	fallthrough
	88	case 'b', 'g', 'G', 'x', 'X':
81	89	if p, ok := st.Precision(); ok {
82	90	prec = p
83		} else {
84		prec = 6
85	91	}
	92	default:
	93	verb, prec = 'f', 0
86	94	}
87	95
88	96	var unit SizeB1000

95	103	unit = _MB
96	104	case self < _TB:
97	105	unit = _GB
98		case self <= math.MaxInt64:
	106	default:
99	107	unit = _TB
100	108	}
101	109
102		io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
103
	110	b := strconv.AppendFloat(make([]byte, 0, 24), float64(self)/float64(unit), byte(verb), prec, 64)
104	111	if st.Flag(' ') {
105		io.WriteString(st, " ")
	112	b = append(b, ' ')
106	113	}
107		io.WriteString(st, unit.String())
	114	b = append(b, []byte(unit.String())...)
	115	_, err := st.Write(b)
	116	if err != nil {
	117	panic(err)
	118	}
108	119	}

+108

-50

decor/size_type_test.go less more

10	10	verb string
11	11	expected string
12	12	}{
13		"verb %f": {12345678, "%f", "11.773756MiB"},
14		"verb %.0f": {12345678, "%.0f", "12MiB"},
15		"verb %.1f": {12345678, "%.1f", "11.8MiB"},
16		"verb %.2f": {12345678, "%.2f", "11.77MiB"},
17		"verb %.3f": {12345678, "%.3f", "11.774MiB"},
18
	13	"verb %d": {12345678, "%d", "12MiB"},
	14	"verb %s": {12345678, "%s", "12MiB"},
	15	"verb %f": {12345678, "%f", "11.773756MiB"},
	16	"verb %.6f": {12345678, "%.6f", "11.773756MiB"},
	17	"verb %.0f": {12345678, "%.0f", "12MiB"},
	18	"verb %.1f": {12345678, "%.1f", "11.8MiB"},
	19	"verb %.2f": {12345678, "%.2f", "11.77MiB"},
	20	"verb %.3f": {12345678, "%.3f", "11.774MiB"},
	21	"verb % d": {12345678, "% d", "12 MiB"},
	22	"verb % s": {12345678, "% s", "12 MiB"},
19	23	"verb % f": {12345678, "% f", "11.773756 MiB"},
	24	"verb % .6f": {12345678, "% .6f", "11.773756 MiB"},
20	25	"verb % .0f": {12345678, "% .0f", "12 MiB"},
21	26	"verb % .1f": {12345678, "% .1f", "11.8 MiB"},
22	27	"verb % .2f": {12345678, "% .2f", "11.77 MiB"},
23	28	"verb % .3f": {12345678, "% .3f", "11.774 MiB"},
24	29
25		"1000 %f": {1000, "%f", "1000.000000b"},
26		"1000 %d": {1000, "%d", "1000b"},
27		"1000 %s": {1000, "%s", "1000b"},
28		"1024 %f": {1024, "%f", "1.000000KiB"},
29		"1024 %d": {1024, "%d", "1KiB"},
30		"1024 %.1f": {1024, "%.1f", "1.0KiB"},
31		"1024 %s": {1024, "%s", "1KiB"},
32		"3MiB+140KiB %f": {3int64(_iMiB) + 140*int64(_iKiB), "%f", "3.136719MiB"},
33		"3MiB+140KiB %d": {3int64(_iMiB) + 140*int64(_iKiB), "%d", "3MiB"},
34		"3MiB+140KiB %.1f": {3int64(_iMiB) + 140*int64(_iKiB), "%.1f", "3.1MiB"},
35		"3MiB+140KiB %s": {3int64(_iMiB) + 140*int64(_iKiB), "%s", "3.13671875MiB"},
36		"2GiB %f": {2 int64(_iGiB), "%f", "2.000000GiB"},
37		"2GiB %d": {2 int64(_iGiB), "%d", "2GiB"},
38		"2GiB %.1f": {2 int64(_iGiB), "%.1f", "2.0GiB"},
39		"2GiB %s": {2 int64(_iGiB), "%s", "2GiB"},
40		"4TiB %f": {4 int64(_iTiB), "%f", "4.000000TiB"},
41		"4TiB %d": {4 int64(_iTiB), "%d", "4TiB"},
42		"4TiB %.1f": {4 int64(_iTiB), "%.1f", "4.0TiB"},
43		"4TiB %s": {4 int64(_iTiB), "%s", "4TiB"},
	30	"1000 %d": {1000, "%d", "1000b"},
	31	"1000 %s": {1000, "%s", "1000b"},
	32	"1000 %f": {1000, "%f", "1000.000000b"},
	33	"1000 %.6f": {1000, "%.6f", "1000.000000b"},
	34	"1000 %.0f": {1000, "%.0f", "1000b"},
	35	"1000 %.1f": {1000, "%.1f", "1000.0b"},
	36	"1000 %.2f": {1000, "%.2f", "1000.00b"},
	37	"1000 %.3f": {1000, "%.3f", "1000.000b"},
	38	"1024 %d": {1024, "%d", "1KiB"},
	39	"1024 %s": {1024, "%s", "1KiB"},
	40	"1024 %f": {1024, "%f", "1.000000KiB"},
	41	"1024 %.6f": {1024, "%.6f", "1.000000KiB"},
	42	"1024 %.0f": {1024, "%.0f", "1KiB"},
	43	"1024 %.1f": {1024, "%.1f", "1.0KiB"},
	44	"1024 %.2f": {1024, "%.2f", "1.00KiB"},
	45	"1024 %.3f": {1024, "%.3f", "1.000KiB"},
	46
	47	"3MiB+100KiB %d": {3int64(_iMiB) + 100*int64(_iKiB), "%d", "3MiB"},
	48	"3MiB+100KiB %s": {3int64(_iMiB) + 100*int64(_iKiB), "%s", "3MiB"},
	49	"3MiB+100KiB %f": {3int64(_iMiB) + 100*int64(_iKiB), "%f", "3.097656MiB"},
	50	"3MiB+100KiB %.6f": {3int64(_iMiB) + 100*int64(_iKiB), "%.6f", "3.097656MiB"},
	51	"3MiB+100KiB %.0f": {3int64(_iMiB) + 100*int64(_iKiB), "%.0f", "3MiB"},
	52	"3MiB+100KiB %.1f": {3int64(_iMiB) + 100*int64(_iKiB), "%.1f", "3.1MiB"},
	53	"3MiB+100KiB %.2f": {3int64(_iMiB) + 100*int64(_iKiB), "%.2f", "3.10MiB"},
	54	"3MiB+100KiB %.3f": {3int64(_iMiB) + 100*int64(_iKiB), "%.3f", "3.098MiB"},
	55
	56	"2GiB %d": {2 int64(_iGiB), "%d", "2GiB"},
	57	"2GiB %s": {2 int64(_iGiB), "%s", "2GiB"},
	58	"2GiB %f": {2 int64(_iGiB), "%f", "2.000000GiB"},
	59	"2GiB %.6f": {2 int64(_iGiB), "%.6f", "2.000000GiB"},
	60	"2GiB %.0f": {2 int64(_iGiB), "%.0f", "2GiB"},
	61	"2GiB %.1f": {2 int64(_iGiB), "%.1f", "2.0GiB"},
	62	"2GiB %.2f": {2 int64(_iGiB), "%.2f", "2.00GiB"},
	63	"2GiB %.3f": {2 int64(_iGiB), "%.3f", "2.000GiB"},
	64
	65	"4TiB %d": {4 int64(_iTiB), "%d", "4TiB"},
	66	"4TiB %s": {4 int64(_iTiB), "%s", "4TiB"},
	67	"4TiB %f": {4 int64(_iTiB), "%f", "4.000000TiB"},
	68	"4TiB %.6f": {4 int64(_iTiB), "%.6f", "4.000000TiB"},
	69	"4TiB %.0f": {4 int64(_iTiB), "%.0f", "4TiB"},
	70	"4TiB %.1f": {4 int64(_iTiB), "%.1f", "4.0TiB"},
	71	"4TiB %.2f": {4 int64(_iTiB), "%.2f", "4.00TiB"},
	72	"4TiB %.3f": {4 int64(_iTiB), "%.3f", "4.000TiB"},
44	73	}
45	74	for name, tc := range cases {
46	75	t.Run(name, func(t *testing.T) {

58	87	verb string
59	88	expected string
60	89	}{
61		"verb %f": {12345678, "%f", "12.345678MB"},
62		"verb %.0f": {12345678, "%.0f", "12MB"},
63		"verb %.1f": {12345678, "%.1f", "12.3MB"},
64		"verb %.2f": {12345678, "%.2f", "12.35MB"},
65		"verb %.3f": {12345678, "%.3f", "12.346MB"},
66
	90	"verb %d": {12345678, "%d", "12MB"},
	91	"verb %s": {12345678, "%s", "12MB"},
	92	"verb %f": {12345678, "%f", "12.345678MB"},
	93	"verb %.6f": {12345678, "%.6f", "12.345678MB"},
	94	"verb %.0f": {12345678, "%.0f", "12MB"},
	95	"verb %.1f": {12345678, "%.1f", "12.3MB"},
	96	"verb %.2f": {12345678, "%.2f", "12.35MB"},
	97	"verb %.3f": {12345678, "%.3f", "12.346MB"},
	98	"verb % d": {12345678, "% d", "12 MB"},
	99	"verb % s": {12345678, "% s", "12 MB"},
67	100	"verb % f": {12345678, "% f", "12.345678 MB"},
	101	"verb % .6f": {12345678, "% .6f", "12.345678 MB"},
68	102	"verb % .0f": {12345678, "% .0f", "12 MB"},
69	103	"verb % .1f": {12345678, "% .1f", "12.3 MB"},
70	104	"verb % .2f": {12345678, "% .2f", "12.35 MB"},
71	105	"verb % .3f": {12345678, "% .3f", "12.346 MB"},
72	106
73		"1000 %f": {1000, "%f", "1.000000KB"},
74		"1000 %d": {1000, "%d", "1KB"},
75		"1000 %s": {1000, "%s", "1KB"},
76		"1024 %f": {1024, "%f", "1.024000KB"},
77		"1024 %d": {1024, "%d", "1KB"},
78		"1024 %.1f": {1024, "%.1f", "1.0KB"},
79		"1024 %s": {1024, "%s", "1.024KB"},
80		"3MB+140KB %f": {3int64(_MB) + 140int64(_KB), "%f", "3.140000MB"},
81		"3MB+140KB %d": {3int64(_MB) + 140int64(_KB), "%d", "3MB"},
82		"3MB+140KB %.1f": {3int64(_MB) + 140int64(_KB), "%.1f", "3.1MB"},
83		"3MB+140KB %s": {3int64(_MB) + 140int64(_KB), "%s", "3.14MB"},
84		"2GB %f": {2 int64(_GB), "%f", "2.000000GB"},
85		"2GB %d": {2 int64(_GB), "%d", "2GB"},
86		"2GB %.1f": {2 int64(_GB), "%.1f", "2.0GB"},
87		"2GB %s": {2 int64(_GB), "%s", "2GB"},
88		"4TB %f": {4 int64(_TB), "%f", "4.000000TB"},
89		"4TB %d": {4 int64(_TB), "%d", "4TB"},
90		"4TB %.1f": {4 int64(_TB), "%.1f", "4.0TB"},
91		"4TB %s": {4 int64(_TB), "%s", "4TB"},
	107	"1000 %d": {1000, "%d", "1KB"},
	108	"1000 %s": {1000, "%s", "1KB"},
	109	"1000 %f": {1000, "%f", "1.000000KB"},
	110	"1000 %.6f": {1000, "%.6f", "1.000000KB"},
	111	"1000 %.0f": {1000, "%.0f", "1KB"},
	112	"1000 %.1f": {1000, "%.1f", "1.0KB"},
	113	"1000 %.2f": {1000, "%.2f", "1.00KB"},
	114	"1000 %.3f": {1000, "%.3f", "1.000KB"},
	115	"1024 %d": {1024, "%d", "1KB"},
	116	"1024 %s": {1024, "%s", "1KB"},
	117	"1024 %f": {1024, "%f", "1.024000KB"},
	118	"1024 %.6f": {1024, "%.6f", "1.024000KB"},
	119	"1024 %.0f": {1024, "%.0f", "1KB"},
	120	"1024 %.1f": {1024, "%.1f", "1.0KB"},
	121	"1024 %.2f": {1024, "%.2f", "1.02KB"},
	122	"1024 %.3f": {1024, "%.3f", "1.024KB"},
	123
	124	"3MB+100KB %d": {3int64(_MB) + 100int64(_KB), "%d", "3MB"},
	125	"3MB+100KB %s": {3int64(_MB) + 100int64(_KB), "%s", "3MB"},
	126	"3MB+100KB %f": {3int64(_MB) + 100int64(_KB), "%f", "3.100000MB"},
	127	"3MB+100KB %.6f": {3int64(_MB) + 100int64(_KB), "%.6f", "3.100000MB"},
	128	"3MB+100KB %.0f": {3int64(_MB) + 100int64(_KB), "%.0f", "3MB"},
	129	"3MB+100KB %.1f": {3int64(_MB) + 100int64(_KB), "%.1f", "3.1MB"},
	130	"3MB+100KB %.2f": {3int64(_MB) + 100int64(_KB), "%.2f", "3.10MB"},
	131	"3MB+100KB %.3f": {3int64(_MB) + 100int64(_KB), "%.3f", "3.100MB"},
	132
	133	"2GB %d": {2 int64(_GB), "%d", "2GB"},
	134	"2GB %s": {2 int64(_GB), "%s", "2GB"},
	135	"2GB %f": {2 int64(_GB), "%f", "2.000000GB"},
	136	"2GB %.6f": {2 int64(_GB), "%.6f", "2.000000GB"},
	137	"2GB %.0f": {2 int64(_GB), "%.0f", "2GB"},
	138	"2GB %.1f": {2 int64(_GB), "%.1f", "2.0GB"},
	139	"2GB %.2f": {2 int64(_GB), "%.2f", "2.00GB"},
	140	"2GB %.3f": {2 int64(_GB), "%.3f", "2.000GB"},
	141
	142	"4TB %d": {4 int64(_TB), "%d", "4TB"},
	143	"4TB %s": {4 int64(_TB), "%s", "4TB"},
	144	"4TB %f": {4 int64(_TB), "%f", "4.000000TB"},
	145	"4TB %.6f": {4 int64(_TB), "%.6f", "4.000000TB"},
	146	"4TB %.0f": {4 int64(_TB), "%.0f", "4TB"},
	147	"4TB %.1f": {4 int64(_TB), "%.1f", "4.0TB"},
	148	"4TB %.2f": {4 int64(_TB), "%.2f", "4.00TB"},
	149	"4TB %.3f": {4 int64(_TB), "%.3f", "4.000TB"},
92	150	}
93	151	for name, tc := range cases {
94	152	t.Run(name, func(t *testing.T) {

+46

-38

decor/speed.go less more

8	8	"github.com/VividCortex/ewma"
9	9	)
10	10
	11	var (
	12	_ Decorator = (*movingAverageSpeed)(nil)
	13	_ EwmaDecorator = (*movingAverageSpeed)(nil)
	14	_ Decorator = (*averageSpeed)(nil)
	15	_ AverageDecorator = (*averageSpeed)(nil)
	16	)
	17
11	18	// FmtAsSpeed adds "/s" to the end of the input formatter. To be
12	19	// used with SizeB1000 or SizeB1024 types, for example:
13	20	//
14	21	// fmt.Printf("%.1f", FmtAsSpeed(SizeB1024(2048)))
15		//
16	22	func FmtAsSpeed(input fmt.Formatter) fmt.Formatter {
17		return &speedFormatter{input}
	23	return speedFormatter{input}
18	24	}
19	25
20	26	type speedFormatter struct {
21	27	fmt.Formatter
22	28	}
23	29
24		func (self *speedFormatter) Format(st fmt.State, verb rune) {
	30	func (self speedFormatter) Format(st fmt.State, verb rune) {
25	31	self.Formatter.Format(st, verb)
26		io.WriteString(st, "/s")
	32	_, err := io.WriteString(st, "/s")
	33	if err != nil {
	34	panic(err)
	35	}
27	36	}
28	37
29	38	// EwmaSpeed exponential-weighted-moving-average based speed decorator.
30		// For this decorator to work correctly you have to measure each
31		// iteration's duration and pass it to the
32		// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
33		func EwmaSpeed(unit int, format string, age float64, wcc ...WC) Decorator {
	39	// For this decorator to work correctly you have to measure each iteration's
	40	// duration and pass it to one of the (*Bar).EwmaIncr... family methods.
	41	func EwmaSpeed(unit interface{}, format string, age float64, wcc ...WC) Decorator {
34	42	var average ewma.MovingAverage
35	43	if age == 0 {
36	44	average = ewma.NewMovingAverage()

43	51	// MovingAverageSpeed decorator relies on MovingAverage implementation
44	52	// to calculate its average.
45	53	//
46		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	54	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
47	55	//
48	56	// `format` printf compatible verb for value, like "%f" or "%d"
49	57	//

53	61	//
54	62	// format examples:
55	63	//
56		// unit=UnitKiB, format="%.1f" output: "1.0MiB/s"
57		// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
58		// unit=UnitKB, format="%.1f" output: "1.0MB/s"
59		// unit=UnitKB, format="% .1f" output: "1.0 MB/s"
60		//
61		func MovingAverageSpeed(unit int, format string, average ewma.MovingAverage, wcc ...WC) Decorator {
62		if format == "" {
63		format = "%.0f"
64		}
	64	// unit=SizeB1024(0), format="%.1f" output: "1.0MiB/s"
	65	// unit=SizeB1024(0), format="% .1f" output: "1.0 MiB/s"
	66	// unit=SizeB1000(0), format="%.1f" output: "1.0MB/s"
	67	// unit=SizeB1000(0), format="% .1f" output: "1.0 MB/s"
	68	func MovingAverageSpeed(unit interface{}, format string, average ewma.MovingAverage, wcc ...WC) Decorator {
65	69	d := &movingAverageSpeed{
66	70	WC: initWC(wcc...),
67	71	average: average,

77	81	msg string
78	82	}
79	83
80		func (d *movingAverageSpeed) Decor(s Statistics) string {
	84	func (d *movingAverageSpeed) Decor(s Statistics) (string, int) {
81	85	if !s.Completed {
82	86	var speed float64
83	87	if v := d.average.Value(); v > 0 {

85	89	}
86	90	d.msg = d.producer(speed * 1e9)
87	91	}
88		return d.FormatMsg(d.msg)
	92	return d.Format(d.msg)
89	93	}
90	94
91	95	func (d *movingAverageSpeed) EwmaUpdate(n int64, dur time.Duration) {

98	102
99	103	// AverageSpeed decorator with dynamic unit measure adjustment. It's
100	104	// a wrapper of NewAverageSpeed.
101		func AverageSpeed(unit int, format string, wcc ...WC) Decorator {
	105	func AverageSpeed(unit interface{}, format string, wcc ...WC) Decorator {
102	106	return NewAverageSpeed(unit, format, time.Now(), wcc...)
103	107	}
104	108
105	109	// NewAverageSpeed decorator with dynamic unit measure adjustment and
106	110	// user provided start time.
107	111	//
108		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	112	// `unit` one of [0\|SizeB1024(0)\|SizeB1000(0)]
109	113	//
110	114	// `format` printf compatible verb for value, like "%f" or "%d"
111	115	//

115	119	//
116	120	// format examples:
117	121	//
118		// unit=UnitKiB, format="%.1f" output: "1.0MiB/s"
119		// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
120		// unit=UnitKB, format="%.1f" output: "1.0MB/s"
121		// unit=UnitKB, format="% .1f" output: "1.0 MB/s"
122		//
123		func NewAverageSpeed(unit int, format string, startTime time.Time, wcc ...WC) Decorator {
124		if format == "" {
125		format = "%.0f"
126		}
	122	// unit=SizeB1024(0), format="%.1f" output: "1.0MiB/s"
	123	// unit=SizeB1024(0), format="% .1f" output: "1.0 MiB/s"
	124	// unit=SizeB1000(0), format="%.1f" output: "1.0MB/s"
	125	// unit=SizeB1000(0), format="% .1f" output: "1.0 MB/s"
	126	func NewAverageSpeed(unit interface{}, format string, startTime time.Time, wcc ...WC) Decorator {
127	127	d := &averageSpeed{
128	128	WC: initWC(wcc...),
129	129	startTime: startTime,

139	139	msg string
140	140	}
141	141
142		func (d *averageSpeed) Decor(s Statistics) string {
	142	func (d *averageSpeed) Decor(s Statistics) (string, int) {
143	143	if !s.Completed {
144	144	speed := float64(s.Current) / float64(time.Since(d.startTime))
145	145	d.msg = d.producer(speed * 1e9)
146	146	}
147
148		return d.FormatMsg(d.msg)
	147	return d.Format(d.msg)
149	148	}
150	149
151	150	func (d *averageSpeed) AverageAdjust(startTime time.Time) {
152	151	d.startTime = startTime
153	152	}
154	153
155		func chooseSpeedProducer(unit int, format string) func(float64) string {
156		switch unit {
157		case UnitKiB:
	154	func chooseSpeedProducer(unit interface{}, format string) func(float64) string {
	155	switch unit.(type) {
	156	case SizeB1024:
	157	if format == "" {
	158	format = "% d"
	159	}
158	160	return func(speed float64) string {
159	161	return fmt.Sprintf(format, FmtAsSpeed(SizeB1024(math.Round(speed))))
160	162	}
161		case UnitKB:
	163	case SizeB1000:
	164	if format == "" {
	165	format = "% d"
	166	}
162	167	return func(speed float64) string {
163	168	return fmt.Sprintf(format, FmtAsSpeed(SizeB1000(math.Round(speed))))
164	169	}
165	170	default:
	171	if format == "" {
	172	format = "%f"
	173	}
166	174	return func(speed float64) string {
167	175	return fmt.Sprintf(format, speed)
168	176	}

+84

-68

decor/speed_test.go less more

4	4	"time"
5	5	)
6	6
7		func TestSpeedKiBDecor(t *testing.T) {
	7	func TestAverageSpeedSizeB1024(t *testing.T) {
8	8	cases := []struct {
9	9	name string
10	10	fmt string
11		unit int
	11	unit interface{}
12	12	current int64
13	13	elapsed time.Duration
14	14	expected string
15	15	}{
16	16	{
17	17	name: "empty fmt",
18		unit: UnitKiB,
	18	unit: SizeB1024(0),
19	19	fmt: "",
20	20	current: 0,
21	21	elapsed: time.Second,
	22	expected: "0 b/s",
	23	},
	24	{
	25	name: "SizeB1024(0):%d:0b",
	26	unit: SizeB1024(0),
	27	fmt: "%d",
	28	current: 0,
	29	elapsed: time.Second,
22	30	expected: "0b/s",
23	31	},
24	32	{
25		name: "UnitKiB:%d:0b",
26		unit: UnitKiB,
27		fmt: "%d",
28		current: 0,
29		elapsed: time.Second,
30		expected: "0b/s",
31		},
32		{
33		name: "UnitKiB:% .2f:0b",
34		unit: UnitKiB,
	33	name: "SizeB1024(0):%f:0b",
	34	unit: SizeB1024(0),
	35	fmt: "%f",
	36	current: 0,
	37	elapsed: time.Second,
	38	expected: "0.000000b/s",
	39	},
	40	{
	41	name: "SizeB1024(0):% .2f:0b",
	42	unit: SizeB1024(0),
35	43	fmt: "% .2f",
36	44	current: 0,
37	45	elapsed: time.Second,
38	46	expected: "0.00 b/s",
39	47	},
40	48	{
41		name: "UnitKiB:%d:1b",
42		unit: UnitKiB,
	49	name: "SizeB1024(0):%d:1b",
	50	unit: SizeB1024(0),
43	51	fmt: "%d",
44	52	current: 1,
45	53	elapsed: time.Second,
46	54	expected: "1b/s",
47	55	},
48	56	{
49		name: "UnitKiB:% .2f:1b",
50		unit: UnitKiB,
	57	name: "SizeB1024(0):% .2f:1b",
	58	unit: SizeB1024(0),
51	59	fmt: "% .2f",
52	60	current: 1,
53	61	elapsed: time.Second,
54	62	expected: "1.00 b/s",
55	63	},
56	64	{
57		name: "UnitKiB:%d:KiB",
58		unit: UnitKiB,
	65	name: "SizeB1024(0):%d:KiB",
	66	unit: SizeB1024(0),
59	67	fmt: "%d",
60	68	current: 2 * int64(_iKiB),
61	69	elapsed: 1 * time.Second,
62	70	expected: "2KiB/s",
63	71	},
64	72	{
65		name: "UnitKiB:% .f:KiB",
66		unit: UnitKiB,
	73	name: "SizeB1024(0):% .f:KiB",
	74	unit: SizeB1024(0),
67	75	fmt: "% .2f",
68	76	current: 2 * int64(_iKiB),
69	77	elapsed: 1 * time.Second,
70	78	expected: "2.00 KiB/s",
71	79	},
72	80	{
73		name: "UnitKiB:%d:MiB",
74		unit: UnitKiB,
	81	name: "SizeB1024(0):%d:MiB",
	82	unit: SizeB1024(0),
75	83	fmt: "%d",
76	84	current: 2 * int64(_iMiB),
77	85	elapsed: 1 * time.Second,
78	86	expected: "2MiB/s",
79	87	},
80	88	{
81		name: "UnitKiB:% .2f:MiB",
82		unit: UnitKiB,
	89	name: "SizeB1024(0):% .2f:MiB",
	90	unit: SizeB1024(0),
83	91	fmt: "% .2f",
84	92	current: 2 * int64(_iMiB),
85	93	elapsed: 1 * time.Second,
86	94	expected: "2.00 MiB/s",
87	95	},
88	96	{
89		name: "UnitKiB:%d:GiB",
90		unit: UnitKiB,
	97	name: "SizeB1024(0):%d:GiB",
	98	unit: SizeB1024(0),
91	99	fmt: "%d",
92	100	current: 2 * int64(_iGiB),
93	101	elapsed: 1 * time.Second,
94	102	expected: "2GiB/s",
95	103	},
96	104	{
97		name: "UnitKiB:% .2f:GiB",
98		unit: UnitKiB,
	105	name: "SizeB1024(0):% .2f:GiB",
	106	unit: SizeB1024(0),
99	107	fmt: "% .2f",
100	108	current: 2 * int64(_iGiB),
101	109	elapsed: 1 * time.Second,
102	110	expected: "2.00 GiB/s",
103	111	},
104	112	{
105		name: "UnitKiB:%d:TiB",
106		unit: UnitKiB,
	113	name: "SizeB1024(0):%d:TiB",
	114	unit: SizeB1024(0),
107	115	fmt: "%d",
108	116	current: 2 * int64(_iTiB),
109	117	elapsed: 1 * time.Second,
110	118	expected: "2TiB/s",
111	119	},
112	120	{
113		name: "UnitKiB:% .2f:TiB",
114		unit: UnitKiB,
	121	name: "SizeB1024(0):% .2f:TiB",
	122	unit: SizeB1024(0),
115	123	fmt: "% .2f",
116	124	current: 2 * int64(_iTiB),
117	125	elapsed: 1 * time.Second,

124	132	stat := Statistics{
125	133	Current: tc.current,
126	134	}
127		res := decor.Decor(stat)
	135	res, _ := decor.Decor(stat)
128	136	if res != tc.expected {
129	137	t.Fatalf("expected: %q, got: %q\n", tc.expected, res)
130	138	}

132	140	}
133	141	}
134	142
135		func TestSpeedKBDecor(t *testing.T) {
	143	func TestAverageSpeedSizeB1000(t *testing.T) {
136	144	cases := []struct {
137	145	name string
138	146	fmt string
139		unit int
	147	unit interface{}
140	148	current int64
141	149	elapsed time.Duration
142	150	expected string
143	151	}{
144	152	{
145	153	name: "empty fmt",
146		unit: UnitKB,
	154	unit: SizeB1000(0),
147	155	fmt: "",
148	156	current: 0,
149	157	elapsed: time.Second,
	158	expected: "0 b/s",
	159	},
	160	{
	161	name: "SizeB1000(0):%d:0b",
	162	unit: SizeB1000(0),
	163	fmt: "%d",
	164	current: 0,
	165	elapsed: time.Second,
150	166	expected: "0b/s",
151	167	},
152	168	{
153		name: "UnitKB:%d:0b",
154		unit: UnitKB,
155		fmt: "%d",
156		current: 0,
157		elapsed: time.Second,
158		expected: "0b/s",
159		},
160		{
161		name: "UnitKB:% .2f:0b",
162		unit: UnitKB,
	169	name: "SizeB1000(0):%f:0b",
	170	unit: SizeB1000(0),
	171	fmt: "%f",
	172	current: 0,
	173	elapsed: time.Second,
	174	expected: "0.000000b/s",
	175	},
	176	{
	177	name: "SizeB1000(0):% .2f:0b",
	178	unit: SizeB1000(0),
163	179	fmt: "% .2f",
164	180	current: 0,
165	181	elapsed: time.Second,
166	182	expected: "0.00 b/s",
167	183	},
168	184	{
169		name: "UnitKB:%d:1b",
170		unit: UnitKB,
	185	name: "SizeB1000(0):%d:1b",
	186	unit: SizeB1000(0),
171	187	fmt: "%d",
172	188	current: 1,
173	189	elapsed: time.Second,
174	190	expected: "1b/s",
175	191	},
176	192	{
177		name: "UnitKB:% .2f:1b",
178		unit: UnitKB,
	193	name: "SizeB1000(0):% .2f:1b",
	194	unit: SizeB1000(0),
179	195	fmt: "% .2f",
180	196	current: 1,
181	197	elapsed: time.Second,
182	198	expected: "1.00 b/s",
183	199	},
184	200	{
185		name: "UnitKB:%d:KB",
186		unit: UnitKB,
	201	name: "SizeB1000(0):%d:KB",
	202	unit: SizeB1000(0),
187	203	fmt: "%d",
188	204	current: 2 * int64(_KB),
189	205	elapsed: 1 * time.Second,
190	206	expected: "2KB/s",
191	207	},
192	208	{
193		name: "UnitKB:% .f:KB",
194		unit: UnitKB,
	209	name: "SizeB1000(0):% .f:KB",
	210	unit: SizeB1000(0),
195	211	fmt: "% .2f",
196	212	current: 2 * int64(_KB),
197	213	elapsed: 1 * time.Second,
198	214	expected: "2.00 KB/s",
199	215	},
200	216	{
201		name: "UnitKB:%d:MB",
202		unit: UnitKB,
	217	name: "SizeB1000(0):%d:MB",
	218	unit: SizeB1000(0),
203	219	fmt: "%d",
204	220	current: 2 * int64(_MB),
205	221	elapsed: 1 * time.Second,
206	222	expected: "2MB/s",
207	223	},
208	224	{
209		name: "UnitKB:% .2f:MB",
210		unit: UnitKB,
	225	name: "SizeB1000(0):% .2f:MB",
	226	unit: SizeB1000(0),
211	227	fmt: "% .2f",
212	228	current: 2 * int64(_MB),
213	229	elapsed: 1 * time.Second,
214	230	expected: "2.00 MB/s",
215	231	},
216	232	{
217		name: "UnitKB:%d:GB",
218		unit: UnitKB,
	233	name: "SizeB1000(0):%d:GB",
	234	unit: SizeB1000(0),
219	235	fmt: "%d",
220	236	current: 2 * int64(_GB),
221	237	elapsed: 1 * time.Second,
222	238	expected: "2GB/s",
223	239	},
224	240	{
225		name: "UnitKB:% .2f:GB",
226		unit: UnitKB,
	241	name: "SizeB1000(0):% .2f:GB",
	242	unit: SizeB1000(0),
227	243	fmt: "% .2f",
228	244	current: 2 * int64(_GB),
229	245	elapsed: 1 * time.Second,
230	246	expected: "2.00 GB/s",
231	247	},
232	248	{
233		name: "UnitKB:%d:TB",
234		unit: UnitKB,
	249	name: "SizeB1000(0):%d:TB",
	250	unit: SizeB1000(0),
235	251	fmt: "%d",
236	252	current: 2 * int64(_TB),
237	253	elapsed: 1 * time.Second,
238	254	expected: "2TB/s",
239	255	},
240	256	{
241		name: "UnitKB:% .2f:TB",
242		unit: UnitKB,
	257	name: "SizeB1000(0):% .2f:TB",
	258	unit: SizeB1000(0),
243	259	fmt: "% .2f",
244	260	current: 2 * int64(_TB),
245	261	elapsed: 1 * time.Second,

252	268	stat := Statistics{
253	269	Current: tc.current,
254	270	}
255		res := decor.Decor(stat)
	271	res, _ := decor.Decor(stat)
256	272	if res != tc.expected {
257	273	t.Fatalf("expected: %q, got: %q\n", tc.expected, res)
258	274	}

+2

-2

decor/spinner.go less more

0	0	package decor
1	1
2		var defaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	2	var defaultSpinnerStyle = [...]string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
3	3
4	4	// Spinner returns spinner decorator.
5	5	//

8	8	// `wcc` optional WC config
9	9	func Spinner(frames []string, wcc ...WC) Decorator {
10	10	if len(frames) == 0 {
11		frames = defaultSpinnerStyle
	11	frames = defaultSpinnerStyle[:]
12	12	}
13	13	var count uint
14	14	f := func(s Statistics) string {

+16

-22

decorators_test.go less more

0	0	package mpb_test
1	1
2	2	import (
3		"sync"
4	3	"testing"
5	4
6		"github.com/vbauerster/mpb/v7"
7		"github.com/vbauerster/mpb/v7/decor"
	5	"github.com/vbauerster/mpb/v8"
	6	"github.com/vbauerster/mpb/v8/decor"
8	7	)
9	8
10	9	func TestNameDecorator(t *testing.T) {

31	30	}
32	31
33	32	for _, test := range tests {
34		got := test.decorator.Decor(decor.Statistics{})
	33	got, _ := test.decorator.Decor(decor.Statistics{})
35	34	if got != test.want {
36	35	t.Errorf("Want: %q, Got: %q\n", test.want, got)
37	36	}

182	181	}
183	182
184	183	for _, columnCase := range testCases {
185		mpb.SyncWidth(toSyncMatrix(columnCase))
186		numBars := len(columnCase)
187		gott := make([]chan string, numBars)
188		wg := new(sync.WaitGroup)
189		wg.Add(numBars)
190		for i, step := range columnCase {
	184	mpb.SyncWidth(toSyncMatrix(columnCase), nil)
	185	var results []chan string
	186	for _, step := range columnCase {
191	187	step := step
192		ch := make(chan string, 1)
	188	ch := make(chan string)
193	189	go func() {
194		defer wg.Done()
195		ch <- step.decorator.Decor(step.stat)
	190	str, _ := step.decorator.Decor(step.stat)
	191	ch <- str
196	192	}()
197		gott[i] = ch
198		}
199		wg.Wait()
200
201		for i, ch := range gott {
202		got := <-ch
	193	results = append(results, ch)
	194	}
	195
	196	for i, ch := range results {
	197	res := <-ch
203	198	want := columnCase[i].want
204		if got != want {
205		t.Errorf("Want: %q, Got: %q\n", want, got)
	199	if res != want {
	200	t.Errorf("Want: %q, Got: %q\n", want, res)
206	201	}
207	202	}
208
209	203	}
210	204	}
211	205

+1128

-113

draw_test.go less more

5	5	"unicode/utf8"
6	6	)
7	7
8		func TestDraw(t *testing.T) {
	8	func TestDrawDefault(t *testing.T) {
9	9	// key is termWidth
10	10	testSuite := map[int][]struct {
11	11	style BarStyleComposer

19	19	}{
20	20	0: {
21	21	{
	22	style: BarStyle(),
22	23	name: "t,c{60,20}",
23	24	total: 60,
24	25	current: 20,
25	26	want: "",
26	27	},
27	28	{
	29	style: BarStyle(),
28	30	name: "t,c{60,20}trim",
29	31	total: 60,
30	32	current: 20,

34	36	},
35	37	1: {
36	38	{
	39	style: BarStyle(),
37	40	name: "t,c{60,20}",
38	41	total: 60,
39	42	current: 20,
40	43	want: "",
41	44	},
42	45	{
	46	style: BarStyle(),
43	47	name: "t,c{60,20}trim",
44	48	total: 60,
45	49	current: 20,

49	53	},
50	54	2: {
51	55	{
	56	style: BarStyle(),
52	57	name: "t,c{60,20}",
53	58	total: 60,
54	59	current: 20,
55	60	want: " ",
56	61	},
57	62	{
	63	style: BarStyle(),
58	64	name: "t,c{60,20}trim",
59	65	total: 60,
60	66	current: 20,

64	70	},
65	71	3: {
66	72	{
	73	style: BarStyle(),
67	74	name: "t,c{60,20}",
68	75	total: 60,
69	76	current: 20,
70	77	want: " ",
71	78	},
72	79	{
	80	style: BarStyle(),
73	81	name: "t,c{60,20}trim",
74	82	total: 60,
75	83	current: 20,
76	84	trim: true,
77	85	want: "[-]",
78	86	},
	87	{
	88	style: BarStyle(),
	89	name: "t,c{60,59}",
	90	total: 60,
	91	current: 59,
	92	want: " ",
	93	},
	94	{
	95	style: BarStyle(),
	96	name: "t,c{60,59}trim",
	97	total: 60,
	98	current: 59,
	99	trim: true,
	100	want: "[>]",
	101	},
	102	{
	103	style: BarStyle(),
	104	name: "t,c{60,60}",
	105	total: 60,
	106	current: 60,
	107	want: " ",
	108	},
	109	{
	110	style: BarStyle(),
	111	name: "t,c{60,60}trim",
	112	total: 60,
	113	current: 60,
	114	trim: true,
	115	want: "[=]",
	116	},
79	117	},
80	118	4: {
81	119	{
	120	style: BarStyle(),
82	121	name: "t,c{60,20}",
83	122	total: 60,
84	123	current: 20,
85	124	want: " [] ",
86	125	},
87	126	{
	127	style: BarStyle(),
88	128	name: "t,c{60,20}trim",
89	129	total: 60,
90	130	current: 20,
91	131	trim: true,
92	132	want: "[>-]",
93	133	},
	134	{
	135	style: BarStyle(),
	136	name: "t,c{60,59}",
	137	total: 60,
	138	current: 59,
	139	want: " [] ",
	140	},
	141	{
	142	style: BarStyle(),
	143	name: "t,c{60,59}trim",
	144	total: 60,
	145	current: 59,
	146	trim: true,
	147	want: "[=>]",
	148	},
	149	{
	150	style: BarStyle(),
	151	name: "t,c{60,60}",
	152	total: 60,
	153	current: 60,
	154	want: " [] ",
	155	},
	156	{
	157	style: BarStyle(),
	158	name: "t,c{60,60}trim",
	159	total: 60,
	160	current: 60,
	161	trim: true,
	162	want: "[==]",
	163	},
94	164	},
95	165	5: {
96	166	{
	167	style: BarStyle(),
97	168	name: "t,c{60,20}",
98	169	total: 60,
99	170	current: 20,
100	171	want: " [-] ",
101	172	},
102	173	{
	174	style: BarStyle(),
103	175	name: "t,c{60,20}trim",
104	176	total: 60,
105	177	current: 20,
106	178	trim: true,
107	179	want: "[>--]",
108	180	},
	181	{
	182	style: BarStyle(),
	183	name: "t,c{60,59}",
	184	total: 60,
	185	current: 59,
	186	want: " [>] ",
	187	},
	188	{
	189	style: BarStyle(),
	190	name: "t,c{60,59}trim",
	191	total: 60,
	192	current: 59,
	193	trim: true,
	194	want: "[==>]",
	195	},
	196	{
	197	style: BarStyle(),
	198	name: "t,c{60,60}",
	199	total: 60,
	200	current: 60,
	201	want: " [=] ",
	202	},
	203	{
	204	style: BarStyle(),
	205	name: "t,c{60,60}trim",
	206	total: 60,
	207	current: 60,
	208	trim: true,
	209	want: "[===]",
	210	},
109	211	},
110	212	6: {
111	213	{
	214	style: BarStyle(),
112	215	name: "t,c{60,20}",
113	216	total: 60,
114	217	current: 20,
115	218	want: " [>-] ",
116	219	},
117	220	{
	221	style: BarStyle(),
118	222	name: "t,c{60,20}trim",
119	223	total: 60,
120	224	current: 20,
121	225	trim: true,
122	226	want: "[>---]",
123	227	},
	228	{
	229	style: BarStyle(),
	230	name: "t,c{60,59}",
	231	total: 60,
	232	current: 59,
	233	want: " [=>] ",
	234	},
	235	{
	236	style: BarStyle(),
	237	name: "t,c{60,59}trim",
	238	total: 60,
	239	current: 59,
	240	trim: true,
	241	want: "[===>]",
	242	},
	243	{
	244	style: BarStyle(),
	245	name: "t,c{60,60}",
	246	total: 60,
	247	current: 60,
	248	want: " [==] ",
	249	},
	250	{
	251	style: BarStyle(),
	252	name: "t,c{60,60}trim",
	253	total: 60,
	254	current: 60,
	255	trim: true,
	256	want: "[====]",
	257	},
124	258	},
125	259	7: {
126	260	{
	261	style: BarStyle(),
127	262	name: "t,c{60,20}",
128	263	total: 60,
129	264	current: 20,
130	265	want: " [>--] ",
131	266	},
132	267	{
	268	style: BarStyle(),
133	269	name: "t,c{60,20}trim",
134	270	total: 60,
135	271	current: 20,
136	272	trim: true,
137	273	want: "[=>---]",
138	274	},
	275	{
	276	style: BarStyle(),
	277	name: "t,c{60,59}",
	278	total: 60,
	279	current: 59,
	280	want: " [==>] ",
	281	},
	282	{
	283	style: BarStyle(),
	284	name: "t,c{60,59}trim",
	285	total: 60,
	286	current: 59,
	287	trim: true,
	288	want: "[====>]",
	289	},
	290	{
	291	style: BarStyle(),
	292	name: "t,c{60,60}",
	293	total: 60,
	294	current: 60,
	295	want: " [===] ",
	296	},
	297	{
	298	style: BarStyle(),
	299	name: "t,c{60,60}trim",
	300	total: 60,
	301	current: 60,
	302	trim: true,
	303	want: "[=====]",
	304	},
139	305	},
140	306	8: {
141	307	{
	308	style: BarStyle(),
142	309	name: "t,c{60,20}",
143	310	total: 60,
144	311	current: 20,
145	312	want: " [>---] ",
146	313	},
147	314	{
	315	style: BarStyle(),
148	316	name: "t,c{60,20}trim",
149	317	total: 60,
150	318	current: 20,
151	319	trim: true,
152	320	want: "[=>----]",
153	321	},
	322	{
	323	style: BarStyle(),
	324	name: "t,c{60,59}",
	325	total: 60,
	326	current: 59,
	327	want: " [===>] ",
	328	},
	329	{
	330	style: BarStyle(),
	331	name: "t,c{60,59}trim",
	332	total: 60,
	333	current: 59,
	334	trim: true,
	335	want: "[=====>]",
	336	},
	337	{
	338	style: BarStyle(),
	339	name: "t,c{60,60}",
	340	total: 60,
	341	current: 60,
	342	want: " [====] ",
	343	},
	344	{
	345	style: BarStyle(),
	346	name: "t,c{60,60}trim",
	347	total: 60,
	348	current: 60,
	349	trim: true,
	350	want: "[======]",
	351	},
154	352	},
155	353	80: {
156	354	{
	355	style: BarStyle(),
157	356	name: "t,c{60,20}",
158	357	total: 60,
159	358	current: 20,
160	359	want: " [========================>---------------------------------------------------] ",
161	360	},
162	361	{
	362	style: BarStyle(),
163	363	name: "t,c{60,20}trim",
164	364	total: 60,
165	365	current: 20,

167	367	want: "[=========================>----------------------------------------------------]",
168	368	},
169	369	{
	370	style: BarStyle(),
170	371	name: "t,c,bw{60,20,60}",
171	372	total: 60,
172	373	current: 20,

174	375	want: " [==================>---------------------------------------] ",
175	376	},
176	377	{
	378	style: BarStyle(),
177	379	name: "t,c,bw{60,20,60}trim",
178	380	total: 60,
179	381	current: 20,

181	383	trim: true,
182	384	want: "[==================>---------------------------------------]",
183	385	},
	386	{
	387	style: BarStyle(),
	388	name: "t,c{60,59}",
	389	total: 60,
	390	current: 59,
	391	want: " [==========================================================================>-] ",
	392	},
	393	{
	394	style: BarStyle(),
	395	name: "t,c{60,59}trim",
	396	total: 60,
	397	current: 59,
	398	trim: true,
	399	want: "[============================================================================>-]",
	400	},
	401	{
	402	style: BarStyle(),
	403	name: "t,c,bw{60,59,60}",
	404	total: 60,
	405	current: 59,
	406	barWidth: 60,
	407	want: " [========================================================>-] ",
	408	},
	409	{
	410	style: BarStyle(),
	411	name: "t,c,bw{60,59,60}trim",
	412	total: 60,
	413	current: 59,
	414	barWidth: 60,
	415	trim: true,
	416	want: "[========================================================>-]",
	417	},
	418	{
	419	style: BarStyle(),
	420	name: "t,c{60,60}",
	421	total: 60,
	422	current: 60,
	423	want: " [============================================================================] ",
	424	},
	425	{
	426	style: BarStyle(),
	427	name: "t,c{60,60}trim",
	428	total: 60,
	429	current: 60,
	430	trim: true,
	431	want: "[==============================================================================]",
	432	},
	433	{
	434	style: BarStyle(),
	435	name: "t,c,bw{60,60,60}",
	436	total: 60,
	437	current: 60,
	438	barWidth: 60,
	439	want: " [==========================================================] ",
	440	},
	441	{
	442	style: BarStyle(),
	443	name: "t,c,bw{60,60,60}trim",
	444	total: 60,
	445	current: 60,
	446	barWidth: 60,
	447	trim: true,
	448	want: "[==========================================================]",
	449	},
184	450	},
185	451	99: {
186	452	{
187		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
188		name: "[のだつ] t,c{99,1}",
189		total: 99,
	453	style: BarStyle(),
	454	name: "t,c{100,1}",
	455	total: 100,
190	456	current: 1,
191		want: " [だつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
192		},
193		{
194		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
195		name: "[のだつ] t,c{99,2}",
196		total: 99,
197		current: 2,
198		want: " [だつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
199		},
200		{
201		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
202		name: "[のだつ] t,c{99,3}",
203		total: 99,
204		current: 3,
205		want: " [だつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
206		},
207		{
208		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
209		name: "[のだつ] t,c{99,4}",
210		total: 99,
211		current: 4,
212		want: " [のだつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
213		},
214		{
215		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
216		name: "[のだつ] t,c{99,5}",
217		total: 99,
218		current: 5,
219		want: " [のだつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
220		},
221		{
222		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]"),
223		name: "[のだつ] t,c{99,6}",
224		total: 99,
225		current: 6,
226		want: " [ののだつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
227		},
228		{
229		style: BarStyle().Lbound("[").Filler("の").Tip("だ").Padding("つ").Rbound("]").Reverse(),
230		name: "[のだつ] t,c{99,6}rev",
231		total: 99,
232		current: 6,
233		want: " […つつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつだのの] ",
	457	want: " [>----------------------------------------------------------------------------------------------] ",
	458	},
	459	{
	460	style: BarStyle(),
	461	name: "t,c{100,1}trim",
	462	total: 100,
	463	current: 1,
	464	trim: true,
	465	want: "[>------------------------------------------------------------------------------------------------]",
	466	},
	467	{
	468	style: BarStyle(),
	469	name: "t,c,r{100,40,33}",
	470	total: 100,
	471	current: 40,
	472	refill: 33,
	473	want: " [+++++++++++++++++++++++++++++++======>---------------------------------------------------------] ",
	474	},
	475	{
	476	style: BarStyle(),
	477	name: "t,c,r{100,40,33}trim",
	478	total: 100,
	479	current: 40,
	480	refill: 33,
	481	trim: true,
	482	want: "[++++++++++++++++++++++++++++++++======>----------------------------------------------------------]",
	483	},
	484	{
	485	style: BarStyle().Tip("<").Reverse(),
	486	name: "t,c,r{100,40,33},rev",
	487	total: 100,
	488	current: 40,
	489	refill: 33,
	490	want: " [---------------------------------------------------------<======+++++++++++++++++++++++++++++++] ",
	491	},
	492	{
	493	style: BarStyle().Tip("<").Reverse(),
	494	name: "t,c,r{100,40,33}trim,rev",
	495	total: 100,
	496	current: 40,
	497	refill: 33,
	498	trim: true,
	499	want: "[----------------------------------------------------------<======++++++++++++++++++++++++++++++++]",
	500	},
	501	{
	502	style: BarStyle(),
	503	name: "t,c{100,99}",
	504	total: 100,
	505	current: 99,
	506	want: " [=============================================================================================>-] ",
	507	},
	508	{
	509	style: BarStyle(),
	510	name: "t,c{100,99}trim",
	511	total: 100,
	512	current: 99,
	513	trim: true,
	514	want: "[===============================================================================================>-]",
	515	},
	516	{
	517	style: BarStyle(),
	518	name: "t,c{100,100}",
	519	total: 100,
	520	current: 100,
	521	want: " [===============================================================================================] ",
	522	},
	523	{
	524	style: BarStyle(),
	525	name: "t,c{100,100}trim",
	526	total: 100,
	527	current: 100,
	528	trim: true,
	529	want: "[=================================================================================================]",
	530	},
	531	{
	532	style: BarStyle(),
	533	name: "t,c,r{100,100,99}",
	534	total: 100,
	535	current: 100,
	536	refill: 99,
	537	want: " [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=] ",
	538	},
	539	{
	540	style: BarStyle(),
	541	name: "t,c,r{100,100,99}trim",
	542	total: 100,
	543	current: 100,
	544	refill: 99,
	545	trim: true,
	546	want: "[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=]",
	547	},
	548	{
	549	style: BarStyle().Reverse(),
	550	name: "t,c,r{100,100,99}rev",
	551	total: 100,
	552	current: 100,
	553	refill: 99,
	554	want: " [=++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	555	},
	556	{
	557	style: BarStyle().Reverse(),
	558	name: "t,c,r{100,100,99}trim,rev",
	559	total: 100,
	560	current: 100,
	561	refill: 99,
	562	trim: true,
	563	want: "[=++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	564	},
	565	{
	566	style: BarStyle(),
	567	name: "t,c,r{100,100,100}",
	568	total: 100,
	569	current: 100,
	570	refill: 100,
	571	want: " [+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	572	},
	573	{
	574	style: BarStyle(),
	575	name: "t,c,r{100,100,100}trim",
	576	total: 100,
	577	current: 100,
	578	refill: 100,
	579	trim: true,
	580	want: "[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	581	},
	582	{
	583	style: BarStyle().Reverse(),
	584	name: "t,c,r{100,100,100}rev",
	585	total: 100,
	586	current: 100,
	587	refill: 100,
	588	want: " [+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	589	},
	590	{
	591	style: BarStyle().Reverse(),
	592	name: "t,c,r{100,100,100}trim",
	593	total: 100,
	594	current: 100,
	595	refill: 100,
	596	trim: true,
	597	want: "[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
234	598	},
235	599	},
236	600	100: {
237	601	{
	602	style: BarStyle(),
238	603	name: "t,c{100,0}",
239	604	total: 100,
240	605	current: 0,
241	606	want: " [------------------------------------------------------------------------------------------------] ",
242	607	},
243	608	{
	609	style: BarStyle(),
244	610	name: "t,c{100,0}trim",
245	611	total: 100,
246	612	current: 0,

248	614	want: "[--------------------------------------------------------------------------------------------------]",
249	615	},
250	616	{
	617	style: BarStyle(),
251	618	name: "t,c{100,1}",
252	619	total: 100,
253	620	current: 1,
254	621	want: " [>-----------------------------------------------------------------------------------------------] ",
255	622	},
256	623	{
	624	style: BarStyle(),
257	625	name: "t,c{100,1}trim",
258	626	total: 100,
259	627	current: 1,

261	629	want: "[>-------------------------------------------------------------------------------------------------]",
262	630	},
263	631	{
	632	style: BarStyle(),
264	633	name: "t,c{100,99}",
265	634	total: 100,
266	635	current: 99,
267	636	want: " [==============================================================================================>-] ",
268	637	},
269	638	{
	639	style: BarStyle(),
270	640	name: "t,c{100,99}trim",
271	641	total: 100,
272	642	current: 99,

274	644	want: "[================================================================================================>-]",
275	645	},
276	646	{
	647	style: BarStyle(),
277	648	name: "t,c{100,100}",
278	649	total: 100,
279	650	current: 100,
280	651	want: " [================================================================================================] ",
281	652	},
282	653	{
	654	style: BarStyle(),
283	655	name: "t,c{100,100}trim",
284	656	total: 100,
285	657	current: 100,

287	659	want: "[==================================================================================================]",
288	660	},
289	661	{
	662	style: BarStyle(),
	663	name: "t,c,r{100,100,99}",
	664	total: 100,
	665	current: 100,
	666	refill: 99,
	667	want: " [+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=] ",
	668	},
	669	{
	670	style: BarStyle(),
	671	name: "t,c,r{100,100,99}trim",
	672	total: 100,
	673	current: 100,
	674	refill: 99,
	675	trim: true,
	676	want: "[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=]",
	677	},
	678	{
	679	style: BarStyle(),
	680	name: "t,c,r{100,100,100}",
	681	total: 100,
	682	current: 100,
	683	refill: 100,
	684	want: " [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	685	},
	686	{
	687	style: BarStyle(),
290	688	name: "t,c,r{100,100,100}trim",
291	689	total: 100,
292	690	current: 100,

295	693	want: "[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
296	694	},
297	695	{
298		name: "t,c{100,33}",
299		total: 100,
300		current: 33,
301		want: " [===============================>----------------------------------------------------------------] ",
302		},
303		{
304		name: "t,c{100,33}trim",
305		total: 100,
306		current: 33,
307		trim: true,
308		want: "[===============================>------------------------------------------------------------------]",
309		},
310		{
311		style: BarStyle().Tip("<").Reverse(),
312		name: "t,c{100,33}trim,rev",
313		total: 100,
314		current: 33,
315		trim: true,
316		want: "[------------------------------------------------------------------<===============================]",
317		},
318		{
319		name: "t,c,r{100,33,33}",
320		total: 100,
321		current: 33,
322		refill: 33,
323		want: " [+++++++++++++++++++++++++++++++>----------------------------------------------------------------] ",
324		},
325		{
326		name: "t,c,r{100,33,33}trim",
327		total: 100,
328		current: 33,
329		refill: 33,
330		trim: true,
331		want: "[+++++++++++++++++++++++++++++++>------------------------------------------------------------------]",
332		},
333		{
334		style: BarStyle().Tip("<").Reverse(),
335		name: "t,c,r{100,33,33}trim,rev",
336		total: 100,
337		current: 33,
338		refill: 33,
339		trim: true,
340		want: "[------------------------------------------------------------------<+++++++++++++++++++++++++++++++]",
341		},
342		{
	696	style: BarStyle().Reverse(),
	697	name: "t,c,r{100,100,99}rev",
	698	total: 100,
	699	current: 100,
	700	refill: 99,
	701	want: " [=+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	702	},
	703	{
	704	style: BarStyle().Reverse(),
	705	name: "t,c,r{100,100,99}trim,rev",
	706	total: 100,
	707	current: 100,
	708	refill: 99,
	709	trim: true,
	710	want: "[=+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	711	},
	712	{
	713	style: BarStyle().Reverse(),
	714	name: "t,c,r{100,100,100}rev",
	715	total: 100,
	716	current: 100,
	717	refill: 100,
	718	want: " [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	719	},
	720	{
	721	style: BarStyle().Reverse(),
	722	name: "t,c,r{100,100,100}trim",
	723	total: 100,
	724	current: 100,
	725	refill: 100,
	726	trim: true,
	727	want: "[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	728	},
	729	{
	730	style: BarStyle(),
343	731	name: "t,c,r{100,40,33}",
344	732	total: 100,
345	733	current: 40,

347	735	want: " [++++++++++++++++++++++++++++++++=====>----------------------------------------------------------] ",
348	736	},
349	737	{
	738	style: BarStyle(),
350	739	name: "t,c,r{100,40,33}trim",
351	740	total: 100,
352	741	current: 40,

370	759	refill: 33,
371	760	trim: true,
372	761	want: "[-----------------------------------------------------------<======++++++++++++++++++++++++++++++++]",
373		},
374		},
375		197: {
376		{
377		name: "t,c,r{97486999,2805950,2805483}trim",
378		total: 97486999,
379		current: 2805950,
380		refill: 2805483,
381		barWidth: 60,
382		trim: true,
383		want: "[+>--------------------------------------------------------]",
384	762	},
385	763	},
386	764	}

388	766	var tmpBuf bytes.Buffer
389	767	for tw, cases := range testSuite {
390	768	for _, tc := range cases {
391		if tc.style == nil {
392		tc.style = BarStyle()
393		}
394		s := newTestState(NewBarFiller(tc.style))
	769	s := newTestState(tc.style.Build())
395	770	s.reqWidth = tc.barWidth
396	771	s.total = tc.total
397	772	s.current = tc.current
398	773	s.trimSpace = tc.trim
399	774	s.refill = tc.refill
	775	s.completed = tc.total > 0 && tc.current >= tc.total
400	776	tmpBuf.Reset()
401		tmpBuf.ReadFrom(s.draw(newStatistics(tw, s)))
	777	r, err := s.draw(newStatistics(tw, s))
	778	if err != nil {
	779	t.FailNow()
	780	}
	781	_, err = tmpBuf.ReadFrom(r)
	782	if err != nil {
	783	t.FailNow()
	784	}
	785	by := tmpBuf.Bytes()
	786
	787	got := string(by[:len(by)-1])
	788	if !utf8.ValidString(got) {
	789	t.Fail()
	790	}
	791	if got != tc.want {
	792	t.Errorf("termWidth:%d %q want: %q %d, got: %q %d\n", tw, tc.name, tc.want, utf8.RuneCountInString(tc.want), got, utf8.RuneCountInString(got))
	793	}
	794	}
	795	}
	796	}
	797
	798	func TestDrawTipOnComplete(t *testing.T) {
	799	// key is termWidth
	800	testSuite := map[int][]struct {
	801	style BarStyleComposer
	802	name string
	803	total int64
	804	current int64
	805	refill int64
	806	barWidth int
	807	trim bool
	808	want string
	809	}{
	810	3: {
	811	{
	812	style: BarStyle().TipOnComplete(),
	813	name: "t,c{60,60}",
	814	total: 60,
	815	current: 60,
	816	want: " ",
	817	},
	818	{
	819	style: BarStyle().TipOnComplete(),
	820	name: "t,c{60,60}trim",
	821	total: 60,
	822	current: 60,
	823	trim: true,
	824	want: "[>]",
	825	},
	826	},
	827	4: {
	828	{
	829	style: BarStyle().TipOnComplete(),
	830	name: "t,c{60,59}",
	831	total: 60,
	832	current: 59,
	833	want: " [] ",
	834	},
	835	{
	836	style: BarStyle().TipOnComplete(),
	837	name: "t,c{60,59}trim",
	838	total: 60,
	839	current: 59,
	840	trim: true,
	841	want: "[=>]",
	842	},
	843	{
	844	style: BarStyle().TipOnComplete(),
	845	name: "t,c{60,60}",
	846	total: 60,
	847	current: 60,
	848	want: " [] ",
	849	},
	850	{
	851	style: BarStyle().TipOnComplete(),
	852	name: "t,c{60,60}trim",
	853	total: 60,
	854	current: 60,
	855	trim: true,
	856	want: "[=>]",
	857	},
	858	},
	859	5: {
	860	{
	861	style: BarStyle().TipOnComplete(),
	862	name: "t,c{60,59}",
	863	total: 60,
	864	current: 59,
	865	want: " [>] ",
	866	},
	867	{
	868	style: BarStyle().TipOnComplete(),
	869	name: "t,c{60,59}trim",
	870	total: 60,
	871	current: 59,
	872	trim: true,
	873	want: "[==>]",
	874	},
	875	{
	876	style: BarStyle().TipOnComplete(),
	877	name: "t,c{60,60}",
	878	total: 60,
	879	current: 60,
	880	want: " [>] ",
	881	},
	882	{
	883	style: BarStyle().TipOnComplete(),
	884	name: "t,c{60,60}trim",
	885	total: 60,
	886	current: 60,
	887	trim: true,
	888	want: "[==>]",
	889	},
	890	},
	891	6: {
	892	{
	893	style: BarStyle().TipOnComplete(),
	894	name: "t,c{60,59}",
	895	total: 60,
	896	current: 59,
	897	want: " [=>] ",
	898	},
	899	{
	900	style: BarStyle().TipOnComplete(),
	901	name: "t,c{60,59}trim",
	902	total: 60,
	903	current: 59,
	904	trim: true,
	905	want: "[===>]",
	906	},
	907	{
	908	style: BarStyle().TipOnComplete(),
	909	name: "t,c{60,60}",
	910	total: 60,
	911	current: 60,
	912	want: " [=>] ",
	913	},
	914	{
	915	style: BarStyle().TipOnComplete(),
	916	name: "t,c{60,60}trim",
	917	total: 60,
	918	current: 60,
	919	trim: true,
	920	want: "[===>]",
	921	},
	922	},
	923	7: {
	924	{
	925	style: BarStyle().TipOnComplete(),
	926	name: "t,c{60,59}",
	927	total: 60,
	928	current: 59,
	929	want: " [==>] ",
	930	},
	931	{
	932	style: BarStyle().TipOnComplete(),
	933	name: "t,c{60,59}trim",
	934	total: 60,
	935	current: 59,
	936	trim: true,
	937	want: "[====>]",
	938	},
	939	{
	940	style: BarStyle().TipOnComplete(),
	941	name: "t,c{60,60}",
	942	total: 60,
	943	current: 60,
	944	want: " [==>] ",
	945	},
	946	{
	947	style: BarStyle().TipOnComplete(),
	948	name: "t,c{60,60}trim",
	949	total: 60,
	950	current: 60,
	951	trim: true,
	952	want: "[====>]",
	953	},
	954	},
	955	8: {
	956	{
	957	style: BarStyle().TipOnComplete(),
	958	name: "t,c{60,59}",
	959	total: 60,
	960	current: 59,
	961	want: " [===>] ",
	962	},
	963	{
	964	style: BarStyle().TipOnComplete(),
	965	name: "t,c{60,59}trim",
	966	total: 60,
	967	current: 59,
	968	trim: true,
	969	want: "[=====>]",
	970	},
	971	{
	972	style: BarStyle().TipOnComplete(),
	973	name: "t,c{60,60}",
	974	total: 60,
	975	current: 60,
	976	want: " [===>] ",
	977	},
	978	{
	979	style: BarStyle().TipOnComplete(),
	980	name: "t,c{60,60}trim",
	981	total: 60,
	982	current: 60,
	983	trim: true,
	984	want: "[=====>]",
	985	},
	986	},
	987	80: {
	988	{
	989	style: BarStyle().TipOnComplete(),
	990	name: "t,c{60,59}",
	991	total: 60,
	992	current: 59,
	993	want: " [==========================================================================>-] ",
	994	},
	995	{
	996	style: BarStyle().TipOnComplete(),
	997	name: "t,c{60,59}trim",
	998	total: 60,
	999	current: 59,
	1000	trim: true,
	1001	want: "[============================================================================>-]",
	1002	},
	1003	{
	1004	style: BarStyle().TipOnComplete(),
	1005	name: "t,c,bw{60,59,60}",
	1006	total: 60,
	1007	current: 59,
	1008	barWidth: 60,
	1009	want: " [========================================================>-] ",
	1010	},
	1011	{
	1012	style: BarStyle().TipOnComplete(),
	1013	name: "t,c,bw{60,59,60}trim",
	1014	total: 60,
	1015	current: 59,
	1016	barWidth: 60,
	1017	trim: true,
	1018	want: "[========================================================>-]",
	1019	},
	1020	{
	1021	style: BarStyle().TipOnComplete(),
	1022	name: "t,c{60,60}",
	1023	total: 60,
	1024	current: 60,
	1025	want: " [===========================================================================>] ",
	1026	},
	1027	{
	1028	style: BarStyle().TipOnComplete(),
	1029	name: "t,c{60,60}trim",
	1030	total: 60,
	1031	current: 60,
	1032	trim: true,
	1033	want: "[=============================================================================>]",
	1034	},
	1035	{
	1036	style: BarStyle().TipOnComplete(),
	1037	name: "t,c,bw{60,60,60}",
	1038	total: 60,
	1039	current: 60,
	1040	barWidth: 60,
	1041	want: " [=========================================================>] ",
	1042	},
	1043	{
	1044	style: BarStyle().TipOnComplete(),
	1045	name: "t,c,bw{60,60,60}trim",
	1046	total: 60,
	1047	current: 60,
	1048	barWidth: 60,
	1049	trim: true,
	1050	want: "[=========================================================>]",
	1051	},
	1052	},
	1053	99: {
	1054	{
	1055	style: BarStyle().TipOnComplete(),
	1056	name: "t,c{100,99}",
	1057	total: 100,
	1058	current: 99,
	1059	want: " [=============================================================================================>-] ",
	1060	},
	1061	{
	1062	style: BarStyle().TipOnComplete(),
	1063	name: "t,c{100,99}trim",
	1064	total: 100,
	1065	current: 99,
	1066	trim: true,
	1067	want: "[===============================================================================================>-]",
	1068	},
	1069	{
	1070	style: BarStyle().TipOnComplete(),
	1071	name: "t,c{100,100}",
	1072	total: 100,
	1073	current: 100,
	1074	want: " [==============================================================================================>] ",
	1075	},
	1076	{
	1077	style: BarStyle().TipOnComplete(),
	1078	name: "t,c{100,100}trim",
	1079	total: 100,
	1080	current: 100,
	1081	trim: true,
	1082	want: "[================================================================================================>]",
	1083	},
	1084	{
	1085	style: BarStyle().TipOnComplete(),
	1086	name: "t,c,r{100,100,99}",
	1087	total: 100,
	1088	current: 100,
	1089	refill: 99,
	1090	want: " [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>] ",
	1091	},
	1092	{
	1093	style: BarStyle().TipOnComplete(),
	1094	name: "t,c,r{100,100,99}trim",
	1095	total: 100,
	1096	current: 100,
	1097	refill: 99,
	1098	trim: true,
	1099	want: "[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>]",
	1100	},
	1101	{
	1102	style: BarStyle().Tip("<").TipOnComplete().Reverse(),
	1103	name: `t,c,r{100,100,99}.Tip("<").TipOnComplete().Reverse()`,
	1104	total: 100,
	1105	current: 100,
	1106	refill: 99,
	1107	want: " [<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	1108	},
	1109	{
	1110	style: BarStyle().Tip("<").TipOnComplete().Reverse(),
	1111	name: `t,c,r{100,100,99}.Tip("<").TipOnComplete().Reverse()trim`,
	1112	total: 100,
	1113	current: 100,
	1114	refill: 99,
	1115	trim: true,
	1116	want: "[<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	1117	},
	1118	{
	1119	style: BarStyle().TipOnComplete(),
	1120	name: "t,c,r{100,100,100}",
	1121	total: 100,
	1122	current: 100,
	1123	refill: 100,
	1124	want: " [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>] ",
	1125	},
	1126	{
	1127	style: BarStyle().TipOnComplete(),
	1128	name: "t,c,r{100,100,100}trim",
	1129	total: 100,
	1130	current: 100,
	1131	refill: 100,
	1132	trim: true,
	1133	want: "[++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>]",
	1134	},
	1135	{
	1136	style: BarStyle().Tip("<").TipOnComplete().Reverse(),
	1137	name: `t,c,r{100,100,100}.Tip("<").TipOnComplete().Reverse()`,
	1138	total: 100,
	1139	current: 100,
	1140	refill: 100,
	1141	want: " [<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++] ",
	1142	},
	1143	{
	1144	style: BarStyle().Tip("<").TipOnComplete().Reverse(),
	1145	name: `t,c,r{100,100,100}.Tip("<").TipOnComplete().Reverse()trim`,
	1146	total: 100,
	1147	current: 100,
	1148	refill: 100,
	1149	trim: true,
	1150	want: "[<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]",
	1151	},
	1152	},
	1153	100: {
	1154	{
	1155	style: BarStyle().TipOnComplete(),
	1156	name: "t,c{100,99}",
	1157	total: 100,
	1158	current: 99,
	1159	want: " [==============================================================================================>-] ",
	1160	},
	1161	{
	1162	style: BarStyle().TipOnComplete(),
	1163	name: "t,c{100,99}trim",
	1164	total: 100,
	1165	current: 99,
	1166	trim: true,
	1167	want: "[================================================================================================>-]",
	1168	},
	1169	{
	1170	style: BarStyle().TipOnComplete(),
	1171	name: "t,c{100,100}",
	1172	total: 100,
	1173	current: 100,
	1174	want: " [===============================================================================================>] ",
	1175	},
	1176	{
	1177	style: BarStyle().TipOnComplete(),
	1178	name: "t,c{100,100}trim",
	1179	total: 100,
	1180	current: 100,
	1181	trim: true,
	1182	want: "[=================================================================================================>]",
	1183	},
	1184	{
	1185	style: BarStyle().TipOnComplete(),
	1186	name: "t,c,r{100,100,99}",
	1187	total: 100,
	1188	current: 100,
	1189	refill: 99,
	1190	want: " [+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>] ",
	1191	},
	1192	{
	1193	style: BarStyle().TipOnComplete(),
	1194	name: "t,c,r{100,100,99}trim",
	1195	total: 100,
	1196	current: 100,
	1197	refill: 99,
	1198	trim: true,
	1199	want: "[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>]",
	1200	},
	1201	{
	1202	style: BarStyle().TipOnComplete(),
	1203	name: "t,c,r{100,100,100}",
	1204	total: 100,
	1205	current: 100,
	1206	refill: 100,
	1207	want: " [+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>] ",
	1208	},
	1209	{
	1210	style: BarStyle().TipOnComplete(),
	1211	name: "t,c,r{100,100,100}trim",
	1212	total: 100,
	1213	current: 100,
	1214	refill: 100,
	1215	trim: true,
	1216	want: "[+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>]",
	1217	},
	1218	},
	1219	}
	1220
	1221	var tmpBuf bytes.Buffer
	1222	for tw, cases := range testSuite {
	1223	for _, tc := range cases {
	1224	s := newTestState(tc.style.Build())
	1225	s.reqWidth = tc.barWidth
	1226	s.total = tc.total
	1227	s.current = tc.current
	1228	s.trimSpace = tc.trim
	1229	s.refill = tc.refill
	1230	s.completed = tc.total > 0 && tc.current >= tc.total
	1231	tmpBuf.Reset()
	1232	r, err := s.draw(newStatistics(tw, s))
	1233	if err != nil {
	1234	t.FailNow()
	1235	}
	1236	_, err = tmpBuf.ReadFrom(r)
	1237	if err != nil {
	1238	t.FailNow()
	1239	}
	1240	by := tmpBuf.Bytes()
	1241
	1242	got := string(by[:len(by)-1])
	1243	if !utf8.ValidString(got) {
	1244	t.Fail()
	1245	}
	1246	if got != tc.want {
	1247	t.Errorf("termWidth:%d %q want: %q %d, got: %q %d\n", tw, tc.name, tc.want, utf8.RuneCountInString(tc.want), got, utf8.RuneCountInString(got))
	1248	}
	1249	}
	1250	}
	1251	}
	1252
	1253	func TestDrawDoubleWidth(t *testing.T) {
	1254	// key is termWidth
	1255	testSuite := map[int][]struct {
	1256	style BarStyleComposer
	1257	name string
	1258	total int64
	1259	current int64
	1260	refill int64
	1261	barWidth int
	1262	trim bool
	1263	want string
	1264	}{
	1265	99: {
	1266	{
	1267	style: BarStyle().Lbound("の").Rbound("の"),
	1268	name: `t,c{100,1}.Lbound("の").Rbound("の")`,
	1269	total: 100,
	1270	current: 1,
	1271	want: " の>--------------------------------------------------------------------------------------------の ",
	1272	},
	1273	{
	1274	style: BarStyle().Lbound("の").Rbound("の"),
	1275	name: `t,c{100,1}.Lbound("の").Rbound("の")`,
	1276	total: 100,
	1277	current: 2,
	1278	want: " の=>-------------------------------------------------------------------------------------------の ",
	1279	},
	1280	{
	1281	style: BarStyle().Tip("だ"),
	1282	name: `t,c{100,1}Tip("だ")`,
	1283	total: 100,
	1284	current: 1,
	1285	want: " [だ---------------------------------------------------------------------------------------------] ",
	1286	},
	1287	{
	1288	style: BarStyle().Tip("だ"),
	1289	name: `t,c{100,2}Tip("だ")`,
	1290	total: 100,
	1291	current: 2,
	1292	want: " [だ---------------------------------------------------------------------------------------------] ",
	1293	},
	1294	{
	1295	style: BarStyle().Tip("だ"),
	1296	name: `t,c{100,3}Tip("だ")`,
	1297	total: 100,
	1298	current: 3,
	1299	want: " [=だ--------------------------------------------------------------------------------------------] ",
	1300	},
	1301	{
	1302	style: BarStyle().Tip("だ"),
	1303	name: `t,c{100,99}Tip("だ")`,
	1304	total: 100,
	1305	current: 99,
	1306	want: " [============================================================================================だ-] ",
	1307	},
	1308	{
	1309	style: BarStyle().Tip("だ"),
	1310	name: `t,c{100,100}Tip("だ")`,
	1311	total: 100,
	1312	current: 100,
	1313	want: " [===============================================================================================] ",
	1314	},
	1315	{
	1316	style: BarStyle().Tip("だ").TipOnComplete(),
	1317	name: `t,c{100,100}.Tip("だ").TipOnComplete()`,
	1318	total: 100,
	1319	current: 100,
	1320	want: " [=============================================================================================だ] ",
	1321	},
	1322	{
	1323	style: BarStyle().Filler("の").Tip("だ").Padding("つ"),
	1324	name: `t,c{100,1}Filler("の").Tip("だ").Padding("つ")`,
	1325	total: 100,
	1326	current: 1,
	1327	want: " [だつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
	1328	},
	1329	{
	1330	style: BarStyle().Filler("の").Tip("だ").Padding("つ"),
	1331	name: `t,c{100,2}Filler("の").Tip("だ").Padding("つ")`,
	1332	total: 100,
	1333	current: 2,
	1334	want: " [だつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつつ…] ",
	1335	},
	1336	{
	1337	style: BarStyle().Filler("の").Tip("だ").Padding("つ"),
	1338	name: `t,c{100,99}Filler("の").Tip("だ").Padding("つ")`,
	1339	total: 100,
	1340	current: 99,
	1341	want: " [ののののののののののののののののののののののののののののののののののののののののののののののだ…] ",
	1342	},
	1343	{
	1344	style: BarStyle().Filler("の").Tip("だ").Padding("つ"),
	1345	name: `t,c{100,100}.Filler("の").Tip("だ").Padding("つ")`,
	1346	total: 100,
	1347	current: 100,
	1348	want: " [ののののののののののののののののののののののののののののののののののののののののののののののの…] ",
	1349	},
	1350	{
	1351	style: BarStyle().Filler("の").Tip("だ").Padding("つ").Reverse(),
	1352	name: `t,c{100,100}Filler("の").Tip("だ").Padding("つ").Reverse()`,
	1353	total: 100,
	1354	current: 100,
	1355	want: " […ののののののののののののののののののののののののののののののののののののののののののののののの] ",
	1356	},
	1357	{
	1358	style: BarStyle().Filler("の").Tip("だ").TipOnComplete().Padding("つ"),
	1359	name: `t,c{100,99}Filler("の").Tip("だ").TipOnComplete().Padding("つ")`,
	1360	total: 100,
	1361	current: 99,
	1362	want: " [ののののののののののののののののののののののののののののののののののののののののののののののだ…] ",
	1363	},
	1364	{
	1365	style: BarStyle().Filler("の").Tip("だ").TipOnComplete().Padding("つ"),
	1366	name: `t,c{100,100}.Filler("の").Tip("だ").TipOnComplete().Padding("つ")`,
	1367	total: 100,
	1368	current: 100,
	1369	want: " [ののののののののののののののののののののののののののののののののののののののののののののののだ…] ",
	1370	},
	1371	{
	1372	style: BarStyle().Filler("の").Tip("だ").TipOnComplete().Padding("つ").Reverse(),
	1373	name: `t,c{100,100}.Filler("の").Tip("だ").TipOnComplete().Padding("つ").Reverse()`,
	1374	total: 100,
	1375	current: 100,
	1376	want: " […だのののののののののののののののののののののののののののののののののののののののののののののの] ",
	1377	},
	1378	{
	1379	style: BarStyle().Refiller("の"),
	1380	name: `t,c,r{100,100,99}Refiller("の")`,
	1381	total: 100,
	1382	current: 100,
	1383	refill: 99,
	1384	want: " [ののののののののののののののののののののののののののののののののののののののののののののののの=] ",
	1385	},
	1386	{
	1387	style: BarStyle().Refiller("の"),
	1388	name: `t,c,r{100,100,99}Refiller("の")trim`,
	1389	total: 100,
	1390	current: 100,
	1391	refill: 99,
	1392	trim: true,
	1393	want: "[のののののののののののののののののののののののののののののののののののののののののののののののの=]",
	1394	},
	1395	},
	1396	}
	1397
	1398	var tmpBuf bytes.Buffer
	1399	for tw, cases := range testSuite {
	1400	for _, tc := range cases {
	1401	s := newTestState(tc.style.Build())
	1402	s.reqWidth = tc.barWidth
	1403	s.total = tc.total
	1404	s.current = tc.current
	1405	s.trimSpace = tc.trim
	1406	s.refill = tc.refill
	1407	s.completed = tc.total > 0 && tc.current >= tc.total
	1408	tmpBuf.Reset()
	1409	r, err := s.draw(newStatistics(tw, s))
	1410	if err != nil {
	1411	t.FailNow()
	1412	}
	1413	_, err = tmpBuf.ReadFrom(r)
	1414	if err != nil {
	1415	t.FailNow()
	1416	}
402	1417	by := tmpBuf.Bytes()
403	1418
404	1419	got := string(by[:len(by)-1])

413	1428	}
414	1429
415	1430	func newTestState(filler BarFiller) *bState {
416		s := &bState{
	1431	bs := &bState{
417	1432	filler: filler,
418		bufP: new(bytes.Buffer),
419		bufB: new(bytes.Buffer),
420		bufA: new(bytes.Buffer),
421	1433	}
422		return s
	1434	for i := 0; i < len(bs.buffers); i++ {
	1435	bs.buffers[i] = bytes.NewBuffer(make([]byte, 0, 512))
	1436	}
	1437	return bs
423	1438	}

+8

-15

example_test.go less more

2	2	import (
3	3	crand "crypto/rand"
4	4	"io"
5		"io/ioutil"
6	5	"math/rand"
7	6	"time"
8	7
9		"github.com/vbauerster/mpb/v7"
10		"github.com/vbauerster/mpb/v7/decor"
	8	"github.com/vbauerster/mpb/v8"
	9	"github.com/vbauerster/mpb/v8/decor"
11	10	)
12	11
13	12	func Example() {

16	15
17	16	total := 100
18	17	name := "Single Bar:"
19		// adding a single bar, which will inherit container's width
20		bar := p.Add(int64(total),
21		// progress bar filler with customized style
22		mpb.NewBarFiller(mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟")),
	18	// create a single bar, which will inherit container's width
	19	bar := p.New(int64(total),
	20	// BarFillerBuilder with custom style
	21	mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟"),
23	22	mpb.PrependDecorators(
24	23	// display our name with one space on the right
25	24	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
26	25	// replace ETA decorator with "done" message, OnComplete event
27	26	decor.OnComplete(
28		// ETA decorator with ewma age of 60, and width reservation of 4
29		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
	27	decor.AverageETA(decor.ET_STYLE_GO, decor.WC{W: 4}), "done",
30	28	),
31	29	),
32	30	mpb.AppendDecorators(decor.Percentage()),

34	32	// simulating some work
35	33	max := 100 * time.Millisecond
36	34	for i := 0; i < total; i++ {
37		// start variable is solely for EWMA calculation
38		// EWMA's unit of measure is an iteration's duration
39		start := time.Now()
40	35	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
41	36	bar.Increment()
42		// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
43		bar.DecoratorEwmaUpdate(time.Since(start))
44	37	}
45	38	// wait for our bar to complete and flush
46	39	p.Wait()

77	70	defer proxyReader.Close()
78	71
79	72	// and copy from reader, ignoring errors
80		io.Copy(ioutil.Discard, proxyReader)
	73	_, _ = io.Copy(io.Discard, proxyReader)
81	74
82	75	p.Wait()
83	76	}

+2

-1

export_test.go less more

1	1
2	2	// make syncWidth func public in test
3	3	var SyncWidth = syncWidth
4		var MaxWidthDistributor = &maxWidthDistributor
	4
	5	type PriorityQueue = priorityQueue

+6

-4

go.mod less more

0		module github.com/vbauerster/mpb/v7
	0	module github.com/vbauerster/mpb/v8
1	1
2	2	require (
3	3	github.com/VividCortex/ewma v1.2.0
4	4	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
5		github.com/mattn/go-runewidth v0.0.13
6		golang.org/x/sys v0.0.0-20210616094352-59db8d763f22
	5	github.com/mattn/go-runewidth v0.0.15
	6	golang.org/x/sys v0.11.0
7	7	)
8	8
9		go 1.14
	9	require github.com/rivo/uniseg v0.4.4 // indirect
	10
	11	go 1.17

+6

-5

go.sum less more

1	1	github.com/VividCortex/ewma v1.2.0/go.mod h1:nz4BbCtbLyFDeC9SUHbtcT5644juEuWfUAUnGx7j5l4=
2	2	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
3	3	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
4		github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
5		github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
6		github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
	4	github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
	5	github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
7	6	github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
8		golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 h1:RqytpXGR1iVNX7psjB3ff8y7sNFinVFvkx1c8SjBkio=
9		golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
	7	github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
	8	github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
	9	golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
	10	golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

+173

-0

heap_manager.go less more

	0	package mpb
	1
	2	import "container/heap"
	3
	4	type heapManager chan heapRequest
	5
	6	type heapCmd int
	7
	8	const (
	9	h_sync heapCmd = iota
	10	h_push
	11	h_iter
	12	h_drain
	13	h_fix
	14	h_state
	15	h_end
	16	)
	17
	18	type heapRequest struct {
	19	cmd heapCmd
	20	data interface{}
	21	}
	22
	23	type iterData struct {
	24	iter chan<- *Bar
	25	drop <-chan struct{}
	26	}
	27
	28	type pushData struct {
	29	bar *Bar
	30	sync bool
	31	}
	32
	33	type fixData struct {
	34	bar *Bar
	35	priority int
	36	lazy bool
	37	}
	38
	39	func (m heapManager) run() {
	40	var bHeap priorityQueue
	41	var pMatrix, aMatrix map[int][]chan int
	42
	43	var l int
	44	var sync bool
	45
	46	for req := range m {
	47	switch req.cmd {
	48	case h_push:
	49	data := req.data.(pushData)
	50	heap.Push(&bHeap, data.bar)
	51	if !sync {
	52	sync = data.sync
	53	}
	54	case h_sync:
	55	if sync \|\| l != bHeap.Len() {
	56	pMatrix = make(map[int][]chan int)
	57	aMatrix = make(map[int][]chan int)
	58	for _, b := range bHeap {
	59	table := b.wSyncTable()
	60	for i, ch := range table[0] {
	61	pMatrix[i] = append(pMatrix[i], ch)
	62	}
	63	for i, ch := range table[1] {
	64	aMatrix[i] = append(aMatrix[i], ch)
	65	}
	66	}
	67	sync = false
	68	l = bHeap.Len()
	69	}
	70	drop := req.data.(<-chan struct{})
	71	syncWidth(pMatrix, drop)
	72	syncWidth(aMatrix, drop)
	73	case h_iter:
	74	data := req.data.(iterData)
	75	drop_iter:
	76	for _, b := range bHeap {
	77	select {
	78	case data.iter <- b:
	79	case <-data.drop:
	80	break drop_iter
	81	}
	82	}
	83	close(data.iter)
	84	case h_drain:
	85	data := req.data.(iterData)
	86	drop_drain:
	87	for bHeap.Len() != 0 {
	88	select {
	89	case data.iter <- heap.Pop(&bHeap).(*Bar):
	90	case <-data.drop:
	91	break drop_drain
	92	}
	93	}
	94	close(data.iter)
	95	case h_fix:
	96	data := req.data.(fixData)
	97	if data.bar.index < 0 {
	98	break
	99	}
	100	data.bar.priority = data.priority
	101	if !data.lazy {
	102	heap.Fix(&bHeap, data.bar.index)
	103	}
	104	case h_state:
	105	ch := req.data.(chan<- bool)
	106	ch <- sync \|\| l != bHeap.Len()
	107	case h_end:
	108	ch := req.data.(chan<- interface{})
	109	if ch != nil {
	110	go func() {
	111	ch <- []*Bar(bHeap)
	112	}()
	113	}
	114	close(m)
	115	}
	116	}
	117	}
	118
	119	func (m heapManager) sync(drop <-chan struct{}) {
	120	m <- heapRequest{cmd: h_sync, data: drop}
	121	}
	122
	123	func (m heapManager) push(b *Bar, sync bool) {
	124	data := pushData{b, sync}
	125	m <- heapRequest{cmd: h_push, data: data}
	126	}
	127
	128	func (m heapManager) iter(iter chan<- *Bar, drop <-chan struct{}) {
	129	data := iterData{iter, drop}
	130	m <- heapRequest{cmd: h_iter, data: data}
	131	}
	132
	133	func (m heapManager) drain(iter chan<- *Bar, drop <-chan struct{}) {
	134	data := iterData{iter, drop}
	135	m <- heapRequest{cmd: h_drain, data: data}
	136	}
	137
	138	func (m heapManager) fix(b *Bar, priority int, lazy bool) {
	139	data := fixData{b, priority, lazy}
	140	m <- heapRequest{cmd: h_fix, data: data}
	141	}
	142
	143	func (m heapManager) state(ch chan<- bool) {
	144	m <- heapRequest{cmd: h_state, data: ch}
	145	}
	146
	147	func (m heapManager) end(ch chan<- interface{}) {
	148	m <- heapRequest{cmd: h_end, data: ch}
	149	}
	150
	151	func syncWidth(matrix map[int][]chan int, drop <-chan struct{}) {
	152	for _, column := range matrix {
	153	go maxWidthDistributor(column, drop)
	154	}
	155	}
	156
	157	func maxWidthDistributor(column []chan int, drop <-chan struct{}) {
	158	var maxWidth int
	159	for _, ch := range column {
	160	select {
	161	case w := <-ch:
	162	if w > maxWidth {
	163	maxWidth = w
	164	}
	165	case <-drop:
	166	return
	167	}
	168	}
	169	for _, ch := range column {
	170	ch <- maxWidth
	171	}
	172	}

+2

-2

internal/percentage.go less more

2	2	import "math"
3	3
4	4	// Percentage is a helper function, to calculate percentage.
5		func Percentage(total, current int64, width int) float64 {
	5	func Percentage(total, current int64, width uint) float64 {
6	6	if total <= 0 {
7	7	return 0
8	8	}

13	13	}
14	14
15	15	// PercentageRound same as Percentage but with math.Round.
16		func PercentageRound(total, current int64, width int) float64 {
	16	func PercentageRound(total, current int64, width uint) float64 {
17	17	return math.Round(Percentage(total, current, width))
18	18	}

+1

-1

internal/percentage_test.go less more

3	3
4	4	func TestPercentage(t *testing.T) {
5	5	// key is barWidth
6		testSuite := map[int][]struct {
	6	testSuite := map[uint][]struct {
7	7	name string
8	8	total int64
9	9	current int64

+0

-6

~~internal/predicate.go~~ less more

0		package internal
1
2		// Predicate helper for internal use.
3		func Predicate(pick bool) func() bool {
4		return func() bool { return pick }
5		}

+14

-9

priority_queue.go less more

0	0	package mpb
1	1
2		// A priorityQueue implements heap.Interface
	2	import "container/heap"
	3
	4	var _ heap.Interface = (*priorityQueue)(nil)
	5
3	6	type priorityQueue []*Bar
4	7
5	8	func (pq priorityQueue) Len() int { return len(pq) }
6	9
7	10	func (pq priorityQueue) Less(i, j int) bool {
8		return pq[i].priority < pq[j].priority
	11	// greater priority pops first
	12	return pq[i].priority > pq[j].priority
9	13	}
10	14
11	15	func (pq priorityQueue) Swap(i, j int) {

15	19	}
16	20
17	21	func (pq *priorityQueue) Push(x interface{}) {
18		s := *pq
	22	n := len(*pq)
19	23	bar := x.(*Bar)
20		bar.index = len(s)
21		s = append(s, bar)
22		*pq = s
	24	bar.index = n
	25	pq = append(pq, bar)
23	26	}
24	27
25	28	func (pq *priorityQueue) Pop() interface{} {
26		s := *pq
27		*pq = s[0 : len(s)-1]
28		bar := s[len(s)-1]
	29	old := *pq
	30	n := len(old)
	31	bar := old[n-1]
	32	old[n-1] = nil // avoid memory leak
29	33	bar.index = -1 // for safety
	34	*pq = old[:n-1]
30	35	return bar
31	36	}

+352

-308

progress.go less more

1	1
2	2	import (
3	3	"bytes"
4		"container/heap"
5	4	"context"
6	5	"fmt"
7	6	"io"
8		"io/ioutil"
9		"log"
10	7	"math"
11	8	"os"
12	9	"sync"
13	10	"time"
14	11
15		"github.com/vbauerster/mpb/v7/cwriter"
16		"github.com/vbauerster/mpb/v7/decor"
	12	"github.com/vbauerster/mpb/v8/cwriter"
	13	"github.com/vbauerster/mpb/v8/decor"
17	14	)
18	15
19	16	const (
20		// default RefreshRate
21		prr = 120 * time.Millisecond
	17	defaultRefreshRate = 150 * time.Millisecond
22	18	)
23	19
24		// Progress represents a container that renders one or more progress
25		// bars.
	20	// DoneError represents an error when `*mpb.Progress` is done but its functionality is requested.
	21	var DoneError = fmt.Errorf("%T instance can't be reused after it's done", (*Progress)(nil))
	22
	23	// Progress represents a container that renders one or more progress bars.
26	24	type Progress struct {
	25	uwg *sync.WaitGroup
	26	pwg, bwg sync.WaitGroup
	27	operateState chan func(*pState)
	28	interceptIO chan func(io.Writer)
	29	done <-chan struct{}
	30	cancel func()
	31	}
	32
	33	// pState holds bars in its priorityQueue, it gets passed to (*Progress).serve monitor goroutine.
	34	type pState struct {
27	35	ctx context.Context
28		uwg *sync.WaitGroup
29		cwg *sync.WaitGroup
30		bwg *sync.WaitGroup
31		operateState chan func(*pState)
32		done chan struct{}
33		refreshCh chan time.Time
34		once sync.Once
35		dlogger *log.Logger
36		}
37
38		// pState holds bars in its priorityQueue. It gets passed to
39		// *Progress.serve(...) monitor goroutine.
40		type pState struct {
41		bHeap priorityQueue
42		heapUpdated bool
43		pMatrix map[int][]chan int
44		aMatrix map[int][]chan int
45		barShutdownQueue []*Bar
	36	hm heapManager
	37	dropS, dropD chan struct{}
	38	renderReq chan time.Time
	39	idCount int
	40	popPriority int
46	41
47	42	// following are provided/overrided by user
48		idCount int
	43	refreshRate time.Duration
49	44	reqWidth int
50	45	popCompleted bool
51		outputDiscarded bool
52		rr time.Duration
53		uwg *sync.WaitGroup
54		externalRefresh <-chan interface{}
55		renderDelay <-chan struct{}
56		shutdownNotifier chan struct{}
57		parkedBars map[Bar]Bar
	46	autoRefresh bool
	47	delayRC <-chan struct{}
	48	manualRC <-chan interface{}
	49	shutdownNotifier chan<- interface{}
	50	queueBars map[Bar]Bar
58	51	output io.Writer
59	52	debugOut io.Writer
	53	uwg *sync.WaitGroup
60	54	}
61	55
62	56	// New creates new Progress container instance. It's not possible to
63		// reuse instance after *Progress.Wait() method has been called.
	57	// reuse instance after (*Progress).Wait method has been called.
64	58	func New(options ...ContainerOption) *Progress {
65	59	return NewWithContext(context.Background(), options...)
66	60	}
67	61
68	62	// NewWithContext creates new Progress container instance with provided
69		// context. It's not possible to reuse instance after *Progress.Wait()
	63	// context. It's not possible to reuse instance after (*Progress).Wait
70	64	// method has been called.
71	65	func NewWithContext(ctx context.Context, options ...ContainerOption) *Progress {
	66	if ctx == nil {
	67	ctx = context.Background()
	68	}
	69	ctx, cancel := context.WithCancel(ctx)
72	70	s := &pState{
73		bHeap: priorityQueue{},
74		rr: prr,
75		parkedBars: make(map[Bar]Bar),
76		output: os.Stdout,
77		debugOut: ioutil.Discard,
	71	ctx: ctx,
	72	hm: make(heapManager),
	73	dropS: make(chan struct{}),
	74	dropD: make(chan struct{}),
	75	renderReq: make(chan time.Time),
	76	refreshRate: defaultRefreshRate,
	77	popPriority: math.MinInt32,
	78	queueBars: make(map[Bar]Bar),
	79	output: os.Stdout,
	80	debugOut: io.Discard,
78	81	}
79	82
80	83	for _, opt := range options {

84	87	}
85	88
86	89	p := &Progress{
87		ctx: ctx,
88	90	uwg: s.uwg,
89		cwg: new(sync.WaitGroup),
90		bwg: new(sync.WaitGroup),
91	91	operateState: make(chan func(*pState)),
92		done: make(chan struct{}),
93		dlogger: log.New(s.debugOut, "[mpb] ", log.Lshortfile),
94		}
95
96		p.cwg.Add(1)
97		go p.serve(s, cwriter.New(s.output))
	92	interceptIO: make(chan func(io.Writer)),
	93	cancel: cancel,
	94	}
	95
	96	cw := cwriter.New(s.output)
	97	if s.manualRC != nil {
	98	done := make(chan struct{})
	99	p.done = done
	100	s.autoRefresh = false
	101	go s.manualRefreshListener(done)
	102	} else if cw.IsTerminal() \|\| s.autoRefresh {
	103	done := make(chan struct{})
	104	p.done = done
	105	s.autoRefresh = true
	106	go s.autoRefreshListener(done)
	107	} else {
	108	p.done = ctx.Done()
	109	s.autoRefresh = false
	110	}
	111
	112	p.pwg.Add(1)
	113	go p.serve(s, cw)
	114	go s.hm.run()
98	115	return p
99	116	}
100	117
101		// AddBar creates a bar with default bar filler. Different filler can
102		// be chosen and applied via `Progress.Add(...) Bar` method.
	118	// AddBar creates a bar with default bar filler.
103	119	func (p Progress) AddBar(total int64, options ...BarOption) Bar {
104		return p.Add(total, NewBarFiller(BarStyle()), options...)
105		}
106
107		// AddSpinner creates a bar with default spinner filler. Different
108		// filler can be chosen and applied via `Progress.Add(...) Bar`
109		// method.
	120	return p.New(total, BarStyle(), options...)
	121	}
	122
	123	// AddSpinner creates a bar with default spinner filler.
110	124	func (p Progress) AddSpinner(total int64, options ...BarOption) Bar {
111		return p.Add(total, NewBarFiller(SpinnerStyle()), options...)
112		}
113
114		// Add creates a bar which renders itself by provided filler.
115		// If `total <= 0` trigger complete event is disabled until reset with *bar.SetTotal(int64, bool).
116		// Panics if Progress instance is done, i.e. called after Progress.Wait().
117		func (p Progress) Add(total int64, filler BarFiller, options ...BarOption) Bar {
	125	return p.New(total, SpinnerStyle(), options...)
	126	}
	127
	128	// New creates a bar by calling `Build` method on provided `BarFillerBuilder`.
	129	func (p Progress) New(total int64, builder BarFillerBuilder, options ...BarOption) Bar {
	130	return p.MustAdd(total, builder.Build(), options...)
	131	}
	132
	133	// MustAdd creates a bar which renders itself by provided BarFiller.
	134	// If `total <= 0` triggering complete event by increment methods is
	135	// disabled. Panics if *Progress instance is done, i.e. called after
	136	// (*Progress).Wait().
	137	func (p Progress) MustAdd(total int64, filler BarFiller, options ...BarOption) Bar {
	138	bar, err := p.Add(total, filler, options...)
	139	if err != nil {
	140	panic(err)
	141	}
	142	return bar
	143	}
	144
	145	// Add creates a bar which renders itself by provided BarFiller.
	146	// If `total <= 0` triggering complete event by increment methods
	147	// is disabled. If *Progress instance is done, i.e. called after
	148	// (*Progress).Wait(), return error == DoneError.
	149	func (p Progress) Add(total int64, filler BarFiller, options ...BarOption) (Bar, error) {
118	150	if filler == nil {
119		filler = BarFillerFunc(func(io.Writer, int, decor.Statistics) {})
120		}
121		p.bwg.Add(1)
122		result := make(chan *Bar)
	151	filler = NopStyle().Build()
	152	}
	153	type result struct {
	154	bar *Bar
	155	bs *bState
	156	}
	157	ch := make(chan result)
123	158	select {
124	159	case p.operateState <- func(ps *pState) {
125	160	bs := ps.makeBarState(total, filler, options...)
126		bar := newBar(p, bs)
127		if bs.runningBar != nil {
128		bs.runningBar.noPop = true
129		ps.parkedBars[bs.runningBar] = bar
	161	bar := newBar(ps.ctx, p, bs)
	162	if bs.waitBar != nil {
	163	ps.queueBars[bs.waitBar] = bar
130	164	} else {
131		heap.Push(&ps.bHeap, bar)
132		ps.heapUpdated = true
	165	ps.hm.push(bar, true)
133	166	}
134	167	ps.idCount++
135		result <- bar
	168	ch <- result{bar, bs}
136	169	}:
137		bar := <-result
138		bar.subscribeDecorators()
139		return bar
	170	res := <-ch
	171	bar, bs := res.bar, res.bs
	172	bar.TraverseDecorators(func(d decor.Decorator) {
	173	if d, ok := d.(decor.AverageDecorator); ok {
	174	bs.averageDecorators = append(bs.averageDecorators, d)
	175	}
	176	if d, ok := d.(decor.EwmaDecorator); ok {
	177	bs.ewmaDecorators = append(bs.ewmaDecorators, d)
	178	}
	179	if d, ok := d.(decor.ShutdownListener); ok {
	180	bs.shutdownListeners = append(bs.shutdownListeners, d)
	181	}
	182	})
	183	return bar, nil
140	184	case <-p.done:
141		p.bwg.Done()
142		panic(fmt.Sprintf("%T instance can't be reused after it's done!", p))
143		}
144		}
145
146		func (p Progress) dropBar(b Bar) {
	185	return nil, DoneError
	186	}
	187	}
	188
	189	func (p Progress) traverseBars(cb func(b Bar) bool) {
	190	iter, drop := make(chan *Bar), make(chan struct{})
147	191	select {
148		case p.operateState <- func(s *pState) {
149		if b.index < 0 {
150		return
151		}
152		heap.Remove(&s.bHeap, b.index)
153		s.heapUpdated = true
	192	case p.operateState <- func(s *pState) { s.hm.iter(iter, drop) }:
	193	for b := range iter {
	194	if cb(b) {
	195	close(drop)
	196	break
	197	}
	198	}
	199	case <-p.done:
	200	}
	201	}
	202
	203	// UpdateBarPriority either immediately or lazy.
	204	// With lazy flag order is updated after the next refresh cycle.
	205	// If you don't care about laziness just use *Bar.SetPriority(int).
	206	func (p Progress) UpdateBarPriority(b Bar, priority int, lazy bool) {
	207	if b == nil {
	208	return
	209	}
	210	select {
	211	case p.operateState <- func(s *pState) { s.hm.fix(b, priority, lazy) }:
	212	case <-p.done:
	213	}
	214	}
	215
	216	// Write is implementation of io.Writer.
	217	// Writing to `*mpb.Progress` will print lines above a running bar.
	218	// Writes aren't flushed immediately, but at next refresh cycle.
	219	// If Write is called after `*mpb.Progress` is done, `mpb.DoneError`
	220	// is returned.
	221	func (p *Progress) Write(b []byte) (int, error) {
	222	type result struct {
	223	n int
	224	err error
	225	}
	226	ch := make(chan result)
	227	select {
	228	case p.interceptIO <- func(w io.Writer) {
	229	n, err := w.Write(b)
	230	ch <- result{n, err}
154	231	}:
	232	res := <-ch
	233	return res.n, res.err
155	234	case <-p.done:
156		}
157		}
158
159		func (p Progress) setBarPriority(b Bar, priority int) {
160		select {
161		case p.operateState <- func(s *pState) {
162		if b.index < 0 {
163		return
164		}
165		b.priority = priority
166		heap.Fix(&s.bHeap, b.index)
167		}:
168		case <-p.done:
169		}
170		}
171
172		// UpdateBarPriority same as *Bar.SetPriority(int).
173		func (p Progress) UpdateBarPriority(b Bar, priority int) {
174		p.setBarPriority(b, priority)
175		}
176
177		// BarCount returns bars count.
178		func (p *Progress) BarCount() int {
179		result := make(chan int, 1)
180		select {
181		case p.operateState <- func(s *pState) { result <- s.bHeap.Len() }:
182		return <-result
183		case <-p.done:
184		return 0
185		}
186		}
187
188		// Wait waits for all bars to complete and finally shutdowns container.
189		// After this method has been called, there is no way to reuse *Progress
190		// instance.
	235	return 0, DoneError
	236	}
	237	}
	238
	239	// Wait waits for all bars to complete and finally shutdowns container. After
	240	// this method has been called, there is no way to reuse (*Progress) instance.
191	241	func (p *Progress) Wait() {
	242	// wait for user wg, if any
192	243	if p.uwg != nil {
193		// wait for user wg
194	244	p.uwg.Wait()
195	245	}
196	246
197		// wait for bars to quit, if any
198	247	p.bwg.Wait()
199
200		p.once.Do(p.shutdown)
201
202		// wait for container to quit
203		p.cwg.Wait()
204		}
205
206		func (p *Progress) shutdown() {
207		close(p.done)
	248	p.Shutdown()
	249	}
	250
	251	// Shutdown cancels any running bar immediately and then shutdowns (*Progress)
	252	// instance. Normally this method shouldn't be called unless you know what you
	253	// are doing. Proper way to shutdown is to call (*Progress).Wait() instead.
	254	func (p *Progress) Shutdown() {
	255	p.cancel()
	256	p.pwg.Wait()
208	257	}
209	258
210	259	func (p Progress) serve(s pState, cw *cwriter.Writer) {
211		defer p.cwg.Done()
212
213		p.refreshCh = s.newTicker(p.done)
	260	defer p.pwg.Done()
	261	render := func() error { return s.render(cw) }
	262	var err error
214	263
215	264	for {
216	265	select {
217	266	case op := <-p.operateState:
218	267	op(s)
219		case <-p.refreshCh:
220		if err := s.render(cw); err != nil {
221		p.dlogger.Println(err)
222		}
223		case <-s.shutdownNotifier:
224		if s.heapUpdated {
225		if err := s.render(cw); err != nil {
226		p.dlogger.Println(err)
	268	case fn := <-p.interceptIO:
	269	fn(cw)
	270	case <-s.renderReq:
	271	e := render()
	272	if e != nil {
	273	p.cancel() // cancel all bars
	274	render = func() error { return nil }
	275	err = e
	276	}
	277	case <-p.done:
	278	update := make(chan bool)
	279	for s.autoRefresh && err == nil {
	280	s.hm.state(update)
	281	if <-update {
	282	err = render()
	283	} else {
	284	break
227	285	}
228	286	}
	287	if err != nil {
	288	_, _ = fmt.Fprintln(s.debugOut, err.Error())
	289	}
	290	s.hm.end(s.shutdownNotifier)
229	291	return
230	292	}
231	293	}
232	294	}
233	295
234		func (s *pState) newTicker(done <-chan struct{}) chan time.Time {
235		ch := make(chan time.Time)
236		if s.shutdownNotifier == nil {
237		s.shutdownNotifier = make(chan struct{})
238		}
239		go func() {
240		if s.renderDelay != nil {
241		<-s.renderDelay
242		}
243		var internalRefresh <-chan time.Time
244		if !s.outputDiscarded {
245		if s.externalRefresh == nil {
246		ticker := time.NewTicker(s.rr)
247		defer ticker.Stop()
248		internalRefresh = ticker.C
249		}
	296	func (s pState) autoRefreshListener(done chan struct{}) {
	297	if s.delayRC != nil {
	298	<-s.delayRC
	299	}
	300	ticker := time.NewTicker(s.refreshRate)
	301	defer ticker.Stop()
	302	for {
	303	select {
	304	case t := <-ticker.C:
	305	s.renderReq <- t
	306	case <-s.ctx.Done():
	307	close(done)
	308	return
	309	}
	310	}
	311	}
	312
	313	func (s pState) manualRefreshListener(done chan struct{}) {
	314	for {
	315	select {
	316	case x := <-s.manualRC:
	317	if t, ok := x.(time.Time); ok {
	318	s.renderReq <- t
	319	} else {
	320	s.renderReq <- time.Now()
	321	}
	322	case <-s.ctx.Done():
	323	close(done)
	324	return
	325	}
	326	}
	327	}
	328
	329	func (s pState) render(cw cwriter.Writer) (err error) {
	330	s.hm.sync(s.dropS)
	331	iter := make(chan *Bar)
	332	go s.hm.iter(iter, s.dropS)
	333
	334	var width, height int
	335	if cw.IsTerminal() {
	336	width, height, err = cw.GetTermSize()
	337	if err != nil {
	338	close(s.dropS)
	339	return err
	340	}
	341	} else {
	342	if s.reqWidth > 0 {
	343	width = s.reqWidth
250	344	} else {
251		s.externalRefresh = nil
252		}
253		for {
254		select {
255		case t := <-internalRefresh:
256		ch <- t
257		case x := <-s.externalRefresh:
258		if t, ok := x.(time.Time); ok {
259		ch <- t
260		} else {
261		ch <- time.Now()
	345	width = 100
	346	}
	347	height = 100
	348	}
	349
	350	for b := range iter {
	351	go b.render(width)
	352	}
	353
	354	return s.flush(cw, height)
	355	}
	356
	357	func (s pState) flush(cw cwriter.Writer, height int) error {
	358	var wg sync.WaitGroup
	359	defer wg.Wait() // waiting for all s.hm.push to complete
	360
	361	var popCount int
	362	var rows []io.Reader
	363
	364	iter := make(chan *Bar)
	365	s.hm.drain(iter, s.dropD)
	366
	367	for b := range iter {
	368	frame := <-b.frameCh
	369	if frame.err != nil {
	370	close(s.dropD)
	371	b.cancel()
	372	return frame.err // b.frameCh is buffered it's ok to return here
	373	}
	374	var usedRows int
	375	for i := len(frame.rows) - 1; i >= 0; i-- {
	376	if row := frame.rows[i]; len(rows) < height {
	377	rows = append(rows, row)
	378	usedRows++
	379	} else {
	380	_, _ = io.Copy(io.Discard, row)
	381	}
	382	}
	383	if frame.shutdown != 0 && !frame.done {
	384	if qb, ok := s.queueBars[b]; ok {
	385	b.cancel()
	386	delete(s.queueBars, b)
	387	qb.priority = b.priority
	388	wg.Add(1)
	389	go func(b *Bar) {
	390	s.hm.push(b, true)
	391	wg.Done()
	392	}(qb)
	393	continue
	394	}
	395	if s.popCompleted && !frame.noPop {
	396	switch frame.shutdown {
	397	case 1:
	398	b.priority = s.popPriority
	399	s.popPriority++
	400	default:
	401	b.cancel()
	402	popCount += usedRows
	403	continue
262	404	}
263		case <-done:
264		close(s.shutdownNotifier)
265		return
266		}
267		}
268		}()
269		return ch
270		}
271
272		func (s pState) render(cw cwriter.Writer) error {
273		if s.heapUpdated {
274		s.updateSyncMatrix()
275		s.heapUpdated = false
276		}
277		syncWidth(s.pMatrix)
278		syncWidth(s.aMatrix)
279
280		tw, err := cw.GetWidth()
281		if err != nil {
282		tw = s.reqWidth
283		}
284		for i := 0; i < s.bHeap.Len(); i++ {
285		bar := s.bHeap[i]
286		go bar.render(tw)
287		}
288
289		return s.flush(cw)
290		}
291
292		func (s pState) flush(cw cwriter.Writer) error {
293		var lineCount int
294		bm := make(map[*Bar]struct{}, s.bHeap.Len())
295		for s.bHeap.Len() > 0 {
296		b := heap.Pop(&s.bHeap).(*Bar)
297		cw.ReadFrom(<-b.frameCh)
298		if b.toShutdown {
299		if b.recoveredPanic != nil {
300		s.barShutdownQueue = append(s.barShutdownQueue, b)
301		b.toShutdown = false
	405	} else if frame.rmOnComplete {
	406	b.cancel()
	407	continue
302	408	} else {
303		// shutdown at next flush
304		// this ensures no bar ends up with less than 100% rendered
305		defer func() {
306		s.barShutdownQueue = append(s.barShutdownQueue, b)
307		}()
308		}
309		}
310		lineCount += b.extendedLines + 1
311		bm[b] = struct{}{}
312		}
313
314		for _, b := range s.barShutdownQueue {
315		if parkedBar := s.parkedBars[b]; parkedBar != nil {
316		parkedBar.priority = b.priority
317		heap.Push(&s.bHeap, parkedBar)
318		delete(s.parkedBars, b)
319		b.toDrop = true
320		}
321		if s.popCompleted && !b.noPop {
322		lineCount -= b.extendedLines + 1
323		b.toDrop = true
324		}
325		if b.toDrop {
326		delete(bm, b)
327		s.heapUpdated = true
328		}
329		b.cancel()
330		}
331		s.barShutdownQueue = s.barShutdownQueue[0:0]
332
333		for b := range bm {
334		heap.Push(&s.bHeap, b)
335		}
336
337		return cw.Flush(lineCount)
338		}
339
340		func (s *pState) updateSyncMatrix() {
341		s.pMatrix = make(map[int][]chan int)
342		s.aMatrix = make(map[int][]chan int)
343		for i := 0; i < s.bHeap.Len(); i++ {
344		bar := s.bHeap[i]
345		table := bar.wSyncTable()
346		pRow, aRow := table[0], table[1]
347
348		for i, ch := range pRow {
349		s.pMatrix[i] = append(s.pMatrix[i], ch)
350		}
351
352		for i, ch := range aRow {
353		s.aMatrix[i] = append(s.aMatrix[i], ch)
354		}
355		}
356		}
357
358		func (s pState) makeBarState(total int64, filler BarFiller, options ...BarOption) bState {
	409	b.cancel()
	410	}
	411	}
	412	wg.Add(1)
	413	go func(b *Bar) {
	414	s.hm.push(b, false)
	415	wg.Done()
	416	}(b)
	417	}
	418
	419	for i := len(rows) - 1; i >= 0; i-- {
	420	_, err := cw.ReadFrom(rows[i])
	421	if err != nil {
	422	return err
	423	}
	424	}
	425
	426	return cw.Flush(len(rows) - popCount)
	427	}
	428
	429	func (s pState) makeBarState(total int64, filler BarFiller, options ...BarOption) *bState {
359	430	bs := &bState{
360		id: s.idCount,
361		priority: s.idCount,
362		reqWidth: s.reqWidth,
363		total: total,
364		filler: filler,
365		extender: func(r io.Reader, _ int, _ decor.Statistics) (io.Reader, int) { return r, 0 },
366		debugOut: s.debugOut,
	431	id: s.idCount,
	432	priority: s.idCount,
	433	reqWidth: s.reqWidth,
	434	total: total,
	435	filler: filler,
	436	renderReq: s.renderReq,
	437	autoRefresh: s.autoRefresh,
367	438	}
368	439
369	440	if total > 0 {

376	447	}
377	448	}
378	449
379		if bs.middleware != nil {
380		bs.filler = bs.middleware(filler)
381		bs.middleware = nil
382		}
383
384		if s.popCompleted && !bs.noPop {
385		bs.priority = -(math.MaxInt32 - s.idCount)
386		}
387
388		bs.bufP = bytes.NewBuffer(make([]byte, 0, 128))
389		bs.bufB = bytes.NewBuffer(make([]byte, 0, 256))
390		bs.bufA = bytes.NewBuffer(make([]byte, 0, 128))
	450	for i := 0; i < len(bs.buffers); i++ {
	451	bs.buffers[i] = bytes.NewBuffer(make([]byte, 0, 512))
	452	}
391	453
392	454	return bs
393	455	}
394
395		func syncWidth(matrix map[int][]chan int) {
396		for _, column := range matrix {
397		go maxWidthDistributor(column)
398		}
399		}
400
401		var maxWidthDistributor = func(column []chan int) {
402		var maxWidth int
403		for _, ch := range column {
404		if w := <-ch; w > maxWidth {
405		maxWidth = w
406		}
407		}
408		for _, ch := range column {
409		ch <- maxWidth
410		}
411		}

+267

-170

progress_test.go less more

1	1
2	2	import (
3	3	"bytes"
	4	"container/heap"
4	5	"context"
5		"io/ioutil"
6		"math/rand"
7		"sync"
	6	"errors"
	7	"io"
	8	"strings"
8	9	"testing"
9	10	"time"
10	11
11		"github.com/vbauerster/mpb/v7"
12		"github.com/vbauerster/mpb/v7/decor"
	12	"github.com/vbauerster/mpb/v8"
	13	"github.com/vbauerster/mpb/v8/decor"
13	14	)
14	15
15		func init() {
16		rand.Seed(time.Now().UnixNano())
17		}
18
19		func TestBarCount(t *testing.T) {
20		p := mpb.New(mpb.WithOutput(ioutil.Discard))
21
22		var wg sync.WaitGroup
23		wg.Add(1)
	16	const (
	17	timeout = 300 * time.Millisecond
	18	)
	19
	20	func TestWithContext(t *testing.T) {
	21	shutdown := make(chan interface{})
	22	ctx, cancel := context.WithCancel(context.Background())
	23	p := mpb.NewWithContext(ctx,
	24	mpb.WithOutput(io.Discard),
	25	mpb.WithShutdownNotifier(shutdown),
	26	)
	27	_ = p.AddBar(0) // never complete bar
	28	_ = p.AddBar(0) // never complete bar
	29	go func() {
	30	time.Sleep(10 * time.Millisecond)
	31	cancel()
	32	}()
	33
	34	p.Wait()
	35
	36	select {
	37	case v := <-shutdown:
	38	if l := len(v.([]*mpb.Bar)); l != 2 {
	39	t.Errorf("Expected len of bars: %d, got: %d", 2, l)
	40	}
	41	case <-time.After(timeout):
	42	t.Errorf("Progress didn't shutdown after %v", timeout)
	43	}
	44	}
	45
	46	func TestShutdownsWithErrFiller(t *testing.T) {
	47	var debug bytes.Buffer
	48	shutdown := make(chan interface{})
	49	p := mpb.New(
	50	mpb.WithShutdownNotifier(shutdown),
	51	mpb.WithOutput(io.Discard),
	52	mpb.WithDebugOutput(&debug),
	53	mpb.WithAutoRefresh(),
	54	)
	55
	56	var errReturnCount int
	57	testError := errors.New("test error")
	58	bar := p.AddBar(100,
	59	mpb.BarFillerMiddleware(func(base mpb.BarFiller) mpb.BarFiller {
	60	return mpb.BarFillerFunc(func(w io.Writer, st decor.Statistics) error {
	61	if st.Current >= 22 {
	62	errReturnCount++
	63	return testError
	64	}
	65	return base.Fill(w, st)
	66	})
	67	}),
	68	)
	69
	70	go func() {
	71	for bar.IsRunning() {
	72	bar.Increment()
	73	time.Sleep(10 * time.Millisecond)
	74	}
	75	}()
	76
	77	p.Wait()
	78
	79	if errReturnCount != 1 {
	80	t.Errorf("Expected errReturnCount: %d, got: %d\n", 1, errReturnCount)
	81	}
	82
	83	select {
	84	case v := <-shutdown:
	85	if l := len(v.([]*mpb.Bar)); l != 0 {
	86	t.Errorf("Expected len of bars: %d, got: %d\n", 0, l)
	87	}
	88	if err := strings.TrimSpace(debug.String()); err != testError.Error() {
	89	t.Errorf("Expected err: %q, got %q\n", testError.Error(), err)
	90	}
	91	case <-time.After(timeout):
	92	t.Errorf("Progress didn't shutdown after %v", timeout)
	93	}
	94	}
	95
	96	func TestShutdownAfterBarAbortWithDrop(t *testing.T) {
	97	shutdown := make(chan interface{})
	98	p := mpb.New(
	99	mpb.WithShutdownNotifier(shutdown),
	100	mpb.WithOutput(io.Discard),
	101	mpb.WithAutoRefresh(),
	102	)
24	103	b := p.AddBar(100)
	104
	105	var count int
	106	for i := 0; !b.Aborted(); i++ {
	107	if i >= 10 {
	108	count++
	109	b.Abort(true)
	110	} else {
	111	b.Increment()
	112	time.Sleep(10 * time.Millisecond)
	113	}
	114	}
	115
	116	p.Wait()
	117
	118	if count != 1 {
	119	t.Errorf("Expected count: %d, got: %d", 1, count)
	120	}
	121
	122	select {
	123	case v := <-shutdown:
	124	if l := len(v.([]*mpb.Bar)); l != 0 {
	125	t.Errorf("Expected len of bars: %d, got: %d", 0, l)
	126	}
	127	case <-time.After(timeout):
	128	t.Errorf("Progress didn't shutdown after %v", timeout)
	129	}
	130	}
	131
	132	func TestShutdownAfterBarAbortWithNoDrop(t *testing.T) {
	133	shutdown := make(chan interface{})
	134	p := mpb.New(
	135	mpb.WithShutdownNotifier(shutdown),
	136	mpb.WithOutput(io.Discard),
	137	mpb.WithAutoRefresh(),
	138	)
	139	b := p.AddBar(100)
	140
	141	var count int
	142	for i := 0; !b.Aborted(); i++ {
	143	if i >= 10 {
	144	count++
	145	b.Abort(false)
	146	} else {
	147	b.Increment()
	148	time.Sleep(10 * time.Millisecond)
	149	}
	150	}
	151
	152	p.Wait()
	153
	154	if count != 1 {
	155	t.Errorf("Expected count: %d, got: %d", 1, count)
	156	}
	157
	158	select {
	159	case v := <-shutdown:
	160	if l := len(v.([]*mpb.Bar)); l != 1 {
	161	t.Errorf("Expected len of bars: %d, got: %d", 1, l)
	162	}
	163	case <-time.After(timeout):
	164	t.Errorf("Progress didn't shutdown after %v", timeout)
	165	}
	166	}
	167
	168	func TestBarPristinePopOrder(t *testing.T) {
	169	shutdown := make(chan interface{})
	170	ctx, cancel := context.WithCancel(context.Background())
	171	p := mpb.NewWithContext(ctx,
	172	mpb.WithOutput(io.Discard), // auto refresh is disabled
	173	mpb.WithShutdownNotifier(shutdown),
	174	)
	175	a := p.AddBar(100, mpb.BarPriority(1), mpb.BarID(1))
	176	b := p.AddBar(100, mpb.BarPriority(2), mpb.BarID(2))
	177	c := p.AddBar(100, mpb.BarPriority(3), mpb.BarID(3))
	178	pristineOrder := []*mpb.Bar{c, b, a}
	179
	180	go cancel()
	181
	182	bars := (<-shutdown).([]*mpb.Bar)
	183	if l := len(bars); l != 3 {
	184	t.Fatalf("Expected len of bars: %d, got: %d", 3, l)
	185	}
	186
	187	p.Wait()
	188	pq := mpb.PriorityQueue(bars)
	189
	190	for _, b := range pristineOrder {
	191	// higher priority pops first
	192	if bar := heap.Pop(&pq).(*mpb.Bar); bar.ID() != b.ID() {
	193	t.Errorf("Expected bar id: %d, got bar id: %d", b.ID(), bar.ID())
	194	}
	195	}
	196	}
	197
	198	func makeUpdateBarPriorityTest(refresh, lazy bool) func(*testing.T) {
	199	return func(t *testing.T) {
	200	shutdown := make(chan interface{})
	201	refreshCh := make(chan interface{})
	202	ctx, cancel := context.WithCancel(context.Background())
	203	p := mpb.NewWithContext(ctx,
	204	mpb.WithOutput(io.Discard),
	205	mpb.WithManualRefresh(refreshCh),
	206	mpb.WithShutdownNotifier(shutdown),
	207	)
	208	a := p.AddBar(100, mpb.BarPriority(1), mpb.BarID(1))
	209	b := p.AddBar(100, mpb.BarPriority(2), mpb.BarID(2))
	210	c := p.AddBar(100, mpb.BarPriority(3), mpb.BarID(3))
	211
	212	p.UpdateBarPriority(c, 2, lazy)
	213	p.UpdateBarPriority(b, 3, lazy)
	214	checkOrder := []*mpb.Bar{b, c, a} // updated order
	215
	216	if refresh {
	217	refreshCh <- time.Now()
	218	} else if lazy {
	219	checkOrder = []*mpb.Bar{c, b, a} // pristine order
	220	}
	221
	222	go cancel()
	223
	224	bars := (<-shutdown).([]*mpb.Bar)
	225	if l := len(bars); l != 3 {
	226	t.Fatalf("Expected len of bars: %d, got: %d", 3, l)
	227	}
	228
	229	p.Wait()
	230	pq := mpb.PriorityQueue(bars)
	231
	232	for _, b := range checkOrder {
	233	// higher priority pops first
	234	if bar := heap.Pop(&pq).(*mpb.Bar); bar.ID() != b.ID() {
	235	t.Errorf("Expected bar id: %d, got bar id: %d", b.ID(), bar.ID())
	236	}
	237	}
	238	}
	239	}
	240
	241	func TestUpdateBarPriority(t *testing.T) {
	242	makeUpdateBarPriorityTest(false, false)(t)
	243	makeUpdateBarPriorityTest(true, false)(t)
	244	}
	245
	246	func TestUpdateBarPriorityLazy(t *testing.T) {
	247	makeUpdateBarPriorityTest(false, true)(t)
	248	makeUpdateBarPriorityTest(true, true)(t)
	249	}
	250
	251	func TestNoOutput(t *testing.T) {
	252	var buf bytes.Buffer
	253	p := mpb.New(mpb.WithOutput(&buf))
	254	bar := p.AddBar(100)
	255
25	256	go func() {
26		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
27		for i := 0; i < 100; i++ {
28		if i == 33 {
29		wg.Done()
30		}
31		b.Increment()
32		time.Sleep((time.Duration(rng.Intn(10)+1) * (10 * time.Millisecond)) / 2)
	257	for !bar.Completed() {
	258	bar.Increment()
33	259	}
34	260	}()
35	261
36		wg.Wait()
37		count := p.BarCount()
38		if count != 1 {
39		t.Errorf("BarCount want: %q, got: %q\n", 1, count)
40		}
41
42		b.Abort(true)
43		p.Wait()
44		}
45
46		func TestBarAbort(t *testing.T) {
47		p := mpb.New(mpb.WithOutput(ioutil.Discard))
48
49		var wg sync.WaitGroup
50		wg.Add(1)
51		bars := make([]*mpb.Bar, 3)
52		for i := 0; i < 3; i++ {
53		b := p.AddBar(100)
54		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
55		go func(n int) {
56		for i := 0; !b.Completed(); i++ {
57		if n == 0 && i >= 33 {
58		b.Abort(true)
59		wg.Done()
60		}
61		b.Increment()
62		time.Sleep((time.Duration(rng.Intn(10)+1) * (10 * time.Millisecond)) / 2)
63		}
64		}(i)
65		bars[i] = b
66		}
67
68		wg.Wait()
69		count := p.BarCount()
70		if count != 2 {
71		t.Errorf("BarCount want: %q, got: %q\n", 2, count)
72		}
73		bars[1].Abort(true)
74		bars[2].Abort(true)
75		p.Wait()
76		}
77
78		func TestWithContext(t *testing.T) {
79		ctx, cancel := context.WithCancel(context.Background())
80		shutdown := make(chan struct{})
81		p := mpb.NewWithContext(ctx,
82		mpb.WithOutput(ioutil.Discard),
83		mpb.WithRefreshRate(50*time.Millisecond),
84		mpb.WithShutdownNotifier(shutdown),
85		)
86
87		total := 10000
88		numBars := 3
89		bars := make([]*mpb.Bar, 0, numBars)
90		for i := 0; i < numBars; i++ {
91		bar := p.AddBar(int64(total))
92		bars = append(bars, bar)
93		go func() {
94		for !bar.Completed() {
95		bar.Increment()
96		time.Sleep(randomDuration(100 * time.Millisecond))
97		}
98		}()
99		}
100
101		time.Sleep(50 * time.Millisecond)
102		cancel()
103
104		p.Wait()
105		select {
106		case <-shutdown:
107		case <-time.After(100 * time.Millisecond):
108		t.Error("Progress didn't stop")
109		}
110		}
111
112		// MaxWidthDistributor shouldn't stuck in the middle while removing or aborting a bar
113		func TestMaxWidthDistributor(t *testing.T) {
114
115		makeWrapper := func(f func([]chan int), start, end chan struct{}) func([]chan int) {
116		return func(column []chan int) {
117		start <- struct{}{}
118		f(column)
119		<-end
120		}
121		}
122
123		ready := make(chan struct{})
124		start := make(chan struct{})
125		end := make(chan struct{})
126		mpb.MaxWidthDistributor = makeWrapper(mpb.MaxWidthDistributor, start, end)
127
128		total := 80
129		numBars := 3
130		p := mpb.New(mpb.WithOutput(ioutil.Discard))
131		for i := 0; i < numBars; i++ {
132		bar := p.AddBar(int64(total),
133		mpb.BarOptional(mpb.BarRemoveOnComplete(), i == 0),
134		mpb.PrependDecorators(
135		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
136		),
137		)
138		go func() {
139		<-ready
140		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
141		for i := 0; i < total; i++ {
142		start := time.Now()
143		if bar.ID() >= numBars-1 && i >= 42 {
144		bar.Abort(true)
145		}
146		time.Sleep((time.Duration(rng.Intn(10)+1) * (10 * time.Millisecond)) / 2)
147		bar.Increment()
148		bar.DecoratorEwmaUpdate(time.Since(start))
149		}
150		}()
151		}
152
153		go func() {
154		<-ready
155		p.Wait()
156		close(start)
157		}()
158
159		res := t.Run("maxWidthDistributor", func(t *testing.T) {
160		close(ready)
161		for v := range start {
162		timer := time.NewTimer(100 * time.Millisecond)
163		select {
164		case end <- v:
165		timer.Stop()
166		case <-timer.C:
167		t.FailNow()
168		}
169		}
170		})
171
172		if !res {
173		t.Error("maxWidthDistributor stuck in the middle")
174		}
175		}
176
177		func getLastLine(bb []byte) []byte {
178		split := bytes.Split(bb, []byte("\n"))
179		return split[len(split)-2]
180		}
181
182		func randomDuration(max time.Duration) time.Duration {
183		return time.Duration(rand.Intn(10)+1) * max / 10
184		}
	262	p.Wait()
	263
	264	if buf.Len() != 0 {
	265	t.Errorf("Expected buf.Len == 0, got: %d\n", buf.Len())
	266	}
	267	}
	268
	269	func TestAddAfterDone(t *testing.T) {
	270	p := mpb.New(mpb.WithOutput(io.Discard))
	271	bar := p.AddBar(100)
	272	bar.IncrBy(100)
	273
	274	p.Wait()
	275
	276	_, err := p.Add(100, nil)
	277
	278	if err != mpb.DoneError {
	279	t.Errorf("Expected %q, got: %q\n", mpb.DoneError, err)
	280	}
	281	}

+49

-43

proxyreader.go less more

1	1
2	2	import (
3	3	"io"
4		"io/ioutil"
5	4	"time"
6	5	)
7	6

10	9	bar *Bar
11	10	}
12	11
13		func (x *proxyReader) Read(p []byte) (int, error) {
	12	func (x proxyReader) Read(p []byte) (int, error) {
14	13	n, err := x.ReadCloser.Read(p)
15	14	x.bar.IncrBy(n)
16		if err == io.EOF {
17		go x.bar.SetTotal(0, true)
18		}
19	15	return n, err
20	16	}
21	17
22	18	type proxyWriterTo struct {
23		io.ReadCloser // *proxyReader
24		wt io.WriterTo
25		bar *Bar
	19	proxyReader
26	20	}
27	21
28		func (x *proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
29		n, err := x.wt.WriteTo(w)
	22	func (x proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	23	n, err := x.ReadCloser.(io.WriterTo).WriteTo(w)
30	24	x.bar.IncrInt64(n)
31		if err == io.EOF {
32		go x.bar.SetTotal(0, true)
33		}
34	25	return n, err
35	26	}
36	27
37	28	type ewmaProxyReader struct {
38		io.ReadCloser // *proxyReader
39		bar *Bar
40		iT time.Time
	29	io.ReadCloser
	30	bar *Bar
41	31	}
42	32
43		func (x *ewmaProxyReader) Read(p []byte) (int, error) {
	33	func (x ewmaProxyReader) Read(p []byte) (int, error) {
	34	start := time.Now()
44	35	n, err := x.ReadCloser.Read(p)
45		if n > 0 {
46		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
47		x.iT = time.Now()
48		}
	36	x.bar.EwmaIncrBy(n, time.Since(start))
49	37	return n, err
50	38	}
51	39
52	40	type ewmaProxyWriterTo struct {
53		io.ReadCloser // *ewmaProxyReader
54		wt io.WriterTo // *proxyWriterTo
55		bar *Bar
56		iT time.Time
	41	ewmaProxyReader
57	42	}
58	43
59		func (x *ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
60		n, err := x.wt.WriteTo(w)
61		if n > 0 {
62		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
63		x.iT = time.Now()
64		}
	44	func (x ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	45	start := time.Now()
	46	n, err := x.ReadCloser.(io.WriterTo).WriteTo(w)
	47	x.bar.EwmaIncrInt64(n, time.Since(start))
65	48	return n, err
66	49	}
67	50
68		func newProxyReader(r io.Reader, bar *Bar) io.ReadCloser {
	51	func newProxyReader(r io.Reader, b *Bar, hasEwma bool) io.ReadCloser {
69	52	rc := toReadCloser(r)
70		rc = &proxyReader{rc, bar}
71
72		if wt, isWriterTo := r.(io.WriterTo); bar.hasEwmaDecorators {
73		now := time.Now()
74		rc = &ewmaProxyReader{rc, bar, now}
75		if isWriterTo {
76		rc = &ewmaProxyWriterTo{rc, wt, bar, now}
	53	if hasEwma {
	54	epr := ewmaProxyReader{rc, b}
	55	if _, ok := r.(io.WriterTo); ok {
	56	return ewmaProxyWriterTo{epr}
77	57	}
78		} else if isWriterTo {
79		rc = &proxyWriterTo{rc, wt, bar}
	58	return epr
80	59	}
81		return rc
	60	pr := proxyReader{rc, b}
	61	if _, ok := r.(io.WriterTo); ok {
	62	return proxyWriterTo{pr}
	63	}
	64	return pr
82	65	}
83	66
84	67	func toReadCloser(r io.Reader) io.ReadCloser {
85	68	if rc, ok := r.(io.ReadCloser); ok {
86	69	return rc
87	70	}
88		return ioutil.NopCloser(r)
	71	return toNopReadCloser(r)
89	72	}
	73
	74	func toNopReadCloser(r io.Reader) io.ReadCloser {
	75	if _, ok := r.(io.WriterTo); ok {
	76	return nopReadCloserWriterTo{r}
	77	}
	78	return nopReadCloser{r}
	79	}
	80
	81	type nopReadCloser struct {
	82	io.Reader
	83	}
	84
	85	func (nopReadCloser) Close() error { return nil }
	86
	87	type nopReadCloserWriterTo struct {
	88	io.Reader
	89	}
	90
	91	func (nopReadCloserWriterTo) Close() error { return nil }
	92
	93	func (c nopReadCloserWriterTo) WriteTo(w io.Writer) (int64, error) {
	94	return c.Reader.(io.WriterTo).WriteTo(w)
	95	}

+49

-22

proxyreader_test.go less more

2	2	import (
3	3	"bytes"
4	4	"io"
5		"io/ioutil"
6	5	"strings"
7	6	"testing"
8	7
9		"github.com/vbauerster/mpb/v7"
	8	"github.com/vbauerster/mpb/v8"
10	9	)
11	10
12	11	const content = `Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do

28	27	}
29	28
30	29	func TestProxyReader(t *testing.T) {
31		p := mpb.New(mpb.WithOutput(ioutil.Discard))
	30	p := mpb.New(mpb.WithOutput(io.Discard))
32	31
33		tReader := &testReader{strings.NewReader(content), false}
	32	tr := &testReader{strings.NewReader(content), false}
34	33
35		bar := p.AddBar(int64(len(content)), mpb.BarFillerTrim())
	34	bar := p.New(int64(len(content)), mpb.NopStyle())
36	35
37	36	var buf bytes.Buffer
38		_, err := io.Copy(&buf, bar.ProxyReader(tReader))
	37	_, err := io.Copy(&buf, bar.ProxyReader(tr))
39	38	if err != nil {
40		t.Errorf("Error copying from reader: %+v\n", err)
	39	t.Errorf("io.Copy: %s\n", err.Error())
41	40	}
42	41
43	42	p.Wait()
44	43
45		if !tReader.called {
	44	if !tr.called {
46	45	t.Error("Read not called")
47	46	}
48	47

51	50	}
52	51	}
53	52
54		type testWriterTo struct {
	53	type testReadCloser struct {
55	54	io.Reader
56		wt io.WriterTo
57	55	called bool
58	56	}
59	57
60		func (wt *testWriterTo) WriteTo(w io.Writer) (n int64, err error) {
61		wt.called = true
62		return wt.wt.WriteTo(w)
	58	func (r *testReadCloser) Close() error {
	59	r.called = true
	60	return nil
63	61	}
64	62
65		func TestProxyWriterTo(t *testing.T) {
66		p := mpb.New(mpb.WithOutput(ioutil.Discard))
	63	func TestProxyReadCloser(t *testing.T) {
	64	p := mpb.New(mpb.WithOutput(io.Discard))
67	65
68		var reader io.Reader = strings.NewReader(content)
69		wt := reader.(io.WriterTo)
70		tReader := &testWriterTo{reader, wt, false}
	66	tr := &testReadCloser{strings.NewReader(content), false}
71	67
72		bar := p.AddBar(int64(len(content)), mpb.BarFillerTrim())
	68	bar := p.New(int64(len(content)), mpb.NopStyle())
	69
	70	rc := bar.ProxyReader(tr)
	71	_, err := io.Copy(io.Discard, rc)
	72	if err != nil {
	73	t.Errorf("io.Copy: %s\n", err.Error())
	74	}
	75	_ = rc.Close()
	76
	77	p.Wait()
	78
	79	if !tr.called {
	80	t.Error("Close not called")
	81	}
	82	}
	83
	84	type testReaderWriterTo struct {
	85	io.Reader
	86	called bool
	87	}
	88
	89	func (r *testReaderWriterTo) WriteTo(w io.Writer) (n int64, err error) {
	90	r.called = true
	91	return r.Reader.(io.WriterTo).WriteTo(w)
	92	}
	93
	94	func TestProxyReaderWriterTo(t *testing.T) {
	95	p := mpb.New(mpb.WithOutput(io.Discard))
	96
	97	tr := &testReaderWriterTo{strings.NewReader(content), false}
	98
	99	bar := p.New(int64(len(content)), mpb.NopStyle())
73	100
74	101	var buf bytes.Buffer
75		_, err := io.Copy(&buf, bar.ProxyReader(tReader))
	102	_, err := io.Copy(&buf, bar.ProxyReader(tr))
76	103	if err != nil {
77		t.Errorf("Error copying from reader: %+v\n", err)
	104	t.Errorf("io.Copy: %s\n", err.Error())
78	105	}
79	106
80	107	p.Wait()
81	108
82		if !tReader.called {
	109	if !tr.called {
83	110	t.Error("WriteTo not called")
84	111	}
85	112

+96

-0

proxywriter.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4	"time"
	5	)
	6
	7	type proxyWriter struct {
	8	io.WriteCloser
	9	bar *Bar
	10	}
	11
	12	func (x proxyWriter) Write(p []byte) (int, error) {
	13	n, err := x.WriteCloser.Write(p)
	14	x.bar.IncrBy(n)
	15	return n, err
	16	}
	17
	18	type proxyReaderFrom struct {
	19	proxyWriter
	20	}
	21
	22	func (x proxyReaderFrom) ReadFrom(r io.Reader) (int64, error) {
	23	n, err := x.WriteCloser.(io.ReaderFrom).ReadFrom(r)
	24	x.bar.IncrInt64(n)
	25	return n, err
	26	}
	27
	28	type ewmaProxyWriter struct {
	29	io.WriteCloser
	30	bar *Bar
	31	}
	32
	33	func (x ewmaProxyWriter) Write(p []byte) (int, error) {
	34	start := time.Now()
	35	n, err := x.WriteCloser.Write(p)
	36	x.bar.EwmaIncrBy(n, time.Since(start))
	37	return n, err
	38	}
	39
	40	type ewmaProxyReaderFrom struct {
	41	ewmaProxyWriter
	42	}
	43
	44	func (x ewmaProxyReaderFrom) ReadFrom(r io.Reader) (int64, error) {
	45	start := time.Now()
	46	n, err := x.WriteCloser.(io.ReaderFrom).ReadFrom(r)
	47	x.bar.EwmaIncrInt64(n, time.Since(start))
	48	return n, err
	49	}
	50
	51	func newProxyWriter(w io.Writer, b *Bar, hasEwma bool) io.WriteCloser {
	52	wc := toWriteCloser(w)
	53	if hasEwma {
	54	epw := ewmaProxyWriter{wc, b}
	55	if _, ok := w.(io.ReaderFrom); ok {
	56	return ewmaProxyReaderFrom{epw}
	57	}
	58	return epw
	59	}
	60	pw := proxyWriter{wc, b}
	61	if _, ok := w.(io.ReaderFrom); ok {
	62	return proxyReaderFrom{pw}
	63	}
	64	return pw
	65	}
	66
	67	func toWriteCloser(w io.Writer) io.WriteCloser {
	68	if wc, ok := w.(io.WriteCloser); ok {
	69	return wc
	70	}
	71	return toNopWriteCloser(w)
	72	}
	73
	74	func toNopWriteCloser(w io.Writer) io.WriteCloser {
	75	if _, ok := w.(io.ReaderFrom); ok {
	76	return nopWriteCloserReaderFrom{w}
	77	}
	78	return nopWriteCloser{w}
	79	}
	80
	81	type nopWriteCloser struct {
	82	io.Writer
	83	}
	84
	85	func (nopWriteCloser) Close() error { return nil }
	86
	87	type nopWriteCloserReaderFrom struct {
	88	io.Writer
	89	}
	90
	91	func (nopWriteCloserReaderFrom) Close() error { return nil }
	92
	93	func (c nopWriteCloserReaderFrom) ReadFrom(r io.Reader) (int64, error) {
	94	return c.Writer.(io.ReaderFrom).ReadFrom(r)
	95	}

+120

-0

proxywriter_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"bytes"
	4	"io"
	5	"strings"
	6	"testing"
	7
	8	"github.com/vbauerster/mpb/v8"
	9	)
	10
	11	type testWriter struct {
	12	io.Writer
	13	called bool
	14	}
	15
	16	func (w *testWriter) Write(p []byte) (n int, err error) {
	17	w.called = true
	18	return w.Writer.Write(p)
	19	}
	20
	21	func TestProxyWriter(t *testing.T) {
	22	p := mpb.New(mpb.WithOutput(io.Discard))
	23
	24	var buf bytes.Buffer
	25	tw := &testWriter{&buf, false}
	26
	27	bar := p.New(int64(len(content)), mpb.NopStyle())
	28
	29	_, err := io.Copy(bar.ProxyWriter(tw), strings.NewReader(content))
	30	if err != nil {
	31	t.Errorf("io.Copy: %s\n", err.Error())
	32	}
	33
	34	p.Wait()
	35
	36	if !tw.called {
	37	t.Error("Read not called")
	38	}
	39
	40	if got := buf.String(); got != content {
	41	t.Errorf("Expected content: %s, got: %s\n", content, got)
	42	}
	43	}
	44
	45	type testWriteCloser struct {
	46	io.Writer
	47	called bool
	48	}
	49
	50	func (w *testWriteCloser) Close() error {
	51	w.called = true
	52	return nil
	53	}
	54
	55	func TestProxyWriteCloser(t *testing.T) {
	56	p := mpb.New(mpb.WithOutput(io.Discard))
	57
	58	var buf bytes.Buffer
	59	tw := &testWriteCloser{&buf, false}
	60
	61	bar := p.New(int64(len(content)), mpb.NopStyle())
	62
	63	wc := bar.ProxyWriter(tw)
	64	_, err := io.Copy(wc, strings.NewReader(content))
	65	if err != nil {
	66	t.Errorf("io.Copy: %s\n", err.Error())
	67	}
	68	_ = wc.Close()
	69
	70	p.Wait()
	71
	72	if !tw.called {
	73	t.Error("Close not called")
	74	}
	75	}
	76
	77	type testWriterReadFrom struct {
	78	io.Writer
	79	called bool
	80	}
	81
	82	func (w *testWriterReadFrom) ReadFrom(r io.Reader) (n int64, err error) {
	83	w.called = true
	84	return w.Writer.(io.ReaderFrom).ReadFrom(r)
	85	}
	86
	87	type dumbReader struct {
	88	r io.Reader
	89	}
	90
	91	func (r dumbReader) Read(p []byte) (int, error) {
	92	return r.r.Read(p)
	93	}
	94
	95	func TestProxyWriterReadFrom(t *testing.T) {
	96	p := mpb.New(mpb.WithOutput(io.Discard))
	97
	98	var buf bytes.Buffer
	99	tw := &testWriterReadFrom{&buf, false}
	100
	101	bar := p.New(int64(len(content)), mpb.NopStyle())
	102
	103	// To trigger ReadFrom, WriteTo needs to be hidden, hence a dumb wrapper
	104	dr := dumbReader{strings.NewReader(content)}
	105	_, err := io.Copy(bar.ProxyWriter(tw), dr)
	106	if err != nil {
	107	t.Errorf("io.Copy: %s\n", err.Error())
	108	}
	109
	110	p.Wait()
	111
	112	if !tw.called {
	113	t.Error("ReadFrom not called")
	114	}
	115
	116	if got := buf.String(); got != content {
	117	t.Errorf("Expected content: %s, got: %s\n", content, got)
	118	}
	119	}