Commit 4011be3e967f4b0078b8a9e111ff376a53f0c581 - golang-github-vbauerster-mpb

Record golang-github-vbauerster-mpb (7.3.2-1) in archive suite sid Andreas Tille 4 years ago

79 changed file(s) with 2024 addition(s) and 688 deletion(s). Raw diff Collapse all Expand all

+35

-0

.github/workflows/test.yml less more

	0	name: Test
	1
	2	on: [push, pull_request]
	3
	4	jobs:
	5	test:
	6	strategy:
	7	matrix:
	8	go-version: [1.16, 1.17]
	9	os: [ubuntu-latest, macos-latest, windows-latest]
	10	runs-on: ${{ matrix.os }}
	11	steps:
	12	- name: Setup Go
	13	uses: actions/setup-go@v2
	14	with:
	15	go-version: ${{ matrix.go-version }}
	16	- name: Checkout code
	17	uses: actions/checkout@v2
	18	- uses: actions/cache@v2
	19	with:
	20	# In order:
	21	# * Module download cache
	22	# * Build cache (Linux)
	23	# * Build cache (Mac)
	24	# * Build cache (Windows)
	25	path: \|
	26	~/go/pkg/mod
	27	~/.cache/go-build
	28	~/Library/Caches/go-build
	29	%LocalAppData%\go-build
	30	key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
	31	restore-keys: \|
	32	${{ runner.os }}-go-
	33	- name: Test
	34	run: go test -race ./...

-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

-9

README.md less more

0	0	# Multi Progress Bar
1	1
2	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)
	3	[![Test status](https://github.com/vbauerster/mpb/actions/workflows/test.yml/badge.svg)](https://github.com/vbauerster/mpb/actions/workflows/test.yml)
5	4	[![Donate with PayPal](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/vbauerster)
6	5
7	6	mpb is a Go lib for rendering progress bars in terminal applications.

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)

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

103	102	}
104	103	}()
105	104	}
106		// Waiting for passed &wg and for all bars to complete and flush
	105	// wait for passed wg and for all bars to complete and flush
107	106	p.Wait()
108	107	```
109	108

-1

_examples/barExtender/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-1

_examples/barExtender/main.go less more

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)

54	55	}
55	56	}()
56	57	}
57		// wait for all bars to complete and flush
	58	// wait for passed wg and for all bars to complete and flush
58	59	p.Wait()
59	60	}

-1

_examples/cancel/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-1

_examples/cancel/main.go less more

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

48	49	}
49	50	}()
50	51	}
51
	52	// wait for passed wg and for all bars to complete and flush
52	53	p.Wait()
53	54	}

-1

_examples/complex/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-1

_examples/complex/main.go less more

15	15
16	16	func main() {
17	17	doneWg := new(sync.WaitGroup)
	18	// passed doneWg will be accounted at p.Wait() call
18	19	p := mpb.New(mpb.WithWaitGroup(doneWg))
19	20	numBars := 4
20	21

63	64	go newTask(doneWg, b, numBars-i)
64	65	}()
65	66	}
66
	67	// wait for passed doneWg and for all bars to complete and flush
67	68	p.Wait()
68	69	}
69	70

-1

_examples/decoratorsOnTop/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-3

_examples/decoratorsOnTop/main.go less more

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())), // 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	func extended(builder mpb.BarFillerBuilder) mpb.BarFiller {
	40	filler := builder.Build()
39	41	return mpb.BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
40	42	filler.Fill(w, reqWidth, st)
41	43	w.Write([]byte("\n"))

-1

_examples/differentWidth/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/differentWidth/main.go less more

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

54	54	}
55	55	}()
56	56	}
57		// wait for all bars to complete and flush
	57	// wait for passed wg and for all bars to complete and flush
58	58	p.Wait()
59	59	}

-1

_examples/dynTotal/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-1

_examples/io/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/io/main.go less more

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	24	decor.CountersKibiByte("% .2f / % .2f"),
25	25	),

-1

_examples/merge/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/merge/main.go less more

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(60))
16	16	total, numBars := 100, 3
17	17	wg.Add(numBars)

58	58	}
59	59	}()
60	60	}
61		// Waiting for passed &wg and for all bars to complete and flush
	61	// wait for passed wg and for all bars to complete and flush
62	62	p.Wait()
63	63	}
64	64

-1

_examples/mexicanBar/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/mexicanBar/main.go less more

19	19	bs.Tip("\u001b[0m⛵\u001b[36;1m")
20	20	bs.Padding("_")
21	21	bs.Rbound("\u001b[0m]")
22		bar := p.Add(int64(total),
23		mpb.NewBarFiller(bs),
	22	bar := p.New(int64(total), bs,
24	23	mpb.PrependDecorators(decor.Name(name)),
25	24	mpb.AppendDecorators(decor.Percentage()),
26	25	)

-1

_examples/multiBars/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-3

_examples/multiBars/main.go less more

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)

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

49	49	}
50	50	}()
51	51	}
52		// Waiting for passed &wg and for all bars to complete and flush
	52	// wait for passed wg and for all bars to complete and flush
53	53	p.Wait()
54	54	}

-1

_examples/panic/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/panic/main.go less more

12	12
13	13	func main() {
14	14	var wg sync.WaitGroup
15		p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
	15	// passed wg will be accounted at p.Wait() call
	16	p := mpb.New(
	17	mpb.WithWaitGroup(&wg),
	18	mpb.WithDebugOutput(os.Stderr),
	19	)
16	20
17	21	wantPanic := strings.Repeat("Panic ", 64)
18	22	numBars := 3

30	34	}
31	35	}()
32	36	}
33
	37	// wait for passed wg and for all bars to complete and flush
34	38	p.Wait()
35	39	}
36	40

-1

_examples/poplog/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-1

_examples/quietMode/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/quietMode/main.go less more

19	19	func main() {
20	20	flag.Parse()
21	21	var wg sync.WaitGroup
22		// pass &wg (optional), so p will wait for it eventually
	22	// passed wg will be accounted at p.Wait() call
23	23	p := mpb.New(
24	24	mpb.WithWaitGroup(&wg),
25	25	mpb.ContainerOptional(

67	67	}
68	68	}()
69	69	}
70		// Waiting for passed &wg and for all bars to complete and flush
	70	// wait for passed wg and for all bars to complete and flush
71	71	p.Wait()
72	72	fmt.Println("done")
73	73	}

-1

_examples/remove/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

+13

-10

_examples/remove/main.go less more

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	43	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()
38	44	if bar.ID() == 2 && i >= 42 {
39		// aborting and removing while bar is running
40		bar.Abort(true)
	45	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	}

-1

_examples/reverseBar/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

+14

-9

_examples/reverseBar/main.go less more

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	19	for i := 0; i < numBars; i++ {
20	20	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),
	21	bar := p.New(int64(total), condBuilder(i == 1),
28	22	mpb.PrependDecorators(
29	23	// simple name decorator
30	24	decor.Name(name),

55	49	}
56	50	}()
57	51	}
58		// Waiting for passed &wg and for all bars to complete and flush
	52	// wait for passed wg and for all bars to complete and flush
59	53	p.Wait()
60	54	}
	55
	56	func condBuilder(cond bool) mpb.BarFillerBuilder {
	57	return mpb.BarFillerBuilderFunc(func() mpb.BarFiller {
	58	bs := mpb.BarStyle()
	59	if cond {
	60	// reverse Bar on cond
	61	bs = bs.Tip("<").Reverse()
	62	}
	63	return bs.Build()
	64	})
	65	}

-1

_examples/singleBar/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-4

_examples/singleBar/main.go less more

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}),

-1

_examples/spinTipBar/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/spinTipBar/main.go less more

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(`-`, `\`, `\|`, `/`),
18	18	mpb.PrependDecorators(decor.Name(name)),
19	19	mpb.AppendDecorators(decor.Percentage()),
20	20	)

-1

_examples/spinnerBar/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

+26

-36

_examples/spinnerBar/main.go less more

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
23	22	for i := 0; i < numBars; i++ {
24	23	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),
	24	bar := p.New(int64(total), condBuilder(i != 0),
	25	mpb.PrependDecorators(
	26	// simple name decorator
	27	decor.Name(name),
	28	),
	29	mpb.AppendDecorators(
	30	// replace ETA decorator with "done" message, OnComplete event
	31	decor.OnComplete(
	32	// ETA decorator with ewma age of 60
	33	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
32	34	),
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
	35	),
	36	)
58	37	// simulating some work
59	38	go func() {
60	39	defer wg.Done()

71	50	}
72	51	}()
73	52	}
74		// wait for all bars to complete and flush
	53	// wait for passed wg and for all bars to complete and flush
75	54	p.Wait()
76	55	}
	56
	57	func condBuilder(cond bool) mpb.BarFillerBuilder {
	58	return mpb.BarFillerBuilderFunc(func() mpb.BarFiller {
	59	if cond {
	60	// spinner Bar on cond
	61	frames := []string{"∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"}
	62	return mpb.SpinnerStyle(frames...).Build()
	63	}
	64	return mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟").Build()
	65	})
	66	}

-1

_examples/spinnerDecorator/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-2

_examples/spinnerDecorator/main.go less more

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	}

-1

_examples/stress/go.mod less more

1	1
2	2	go 1.14
3	3
4		require github.com/vbauerster/mpb/v7 v7.0.3
	4	require github.com/vbauerster/mpb/v7 v7.3.2

-5

_examples/stress/main.go less more

15	15
16	16	func main() {
17	17	var wg sync.WaitGroup
18		p := mpb.New(
19		mpb.WithWaitGroup(&wg),
20		mpb.WithRefreshRate(50*time.Millisecond),
21		)
	18	// passed wg will be accounted at p.Wait() call
	19	p := mpb.New(mpb.WithWaitGroup(&wg))
22	20	wg.Add(totalBars)
23	21
24	22	for i := 0; i < totalBars; i++ {

46	44	}
47	45	}()
48	46	}
49
	47	// wait for passed wg and for all bars to complete and flush
50	48	p.Wait()
51	49	}

-1

_examples/suppressBar/go.mod less more

3	3
4	4	require (
5	5	github.com/mattn/go-runewidth v0.0.13
6		github.com/vbauerster/mpb/v7 v7.0.3
	6	github.com/vbauerster/mpb/v7 v7.3.2
7	7	)

-0

_examples/tipOnComplete/go.mod less more

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

+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/v7"
	7	"github.com/vbauerster/mpb/v7/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	}

+191

-114

bar.go less more

4	4	"context"
5	5	"fmt"
6	6	"io"
7		"log"
8	7	"runtime/debug"
9	8	"strings"
	9	"sync"
10	10	"time"
11	11
12	12	"github.com/acarl005/stripansi"

19	19	priority int // used by heap
20	20	index int // used by heap
21	21
22		extendedLines int
23	22	toShutdown bool
24	23	toDrop bool
25	24	noPop bool
26	25	hasEwmaDecorators bool
27	26	operateState chan func(*bState)
28		frameCh chan io.Reader
29		syncTableCh chan [][]chan int
30		completed chan bool
	27	frameCh chan *frame
31	28
32	29	// cancel is called either by user or on complete event
33	30	cancel func()
34	31	// done is closed after cacheState is assigned
35	32	done chan struct{}
36		// cacheState is populated, right after close(shutdown)
	33	// cacheState is populated, right after close(b.done)
37	34	cacheState *bState
38	35
39	36	container *Progress
40		dlogger *log.Logger
41	37	recoveredPanic interface{}
42	38	}
43	39

52	48	total int64
53	49	current int64
54	50	refill int64
55		lastN int64
56		iterated bool
	51	lastIncrement int64
57	52	trimSpace bool
58	53	completed bool
59	54	completeFlushed bool
	55	aborted bool
60	56	triggerComplete bool
61	57	dropOnComplete bool
62	58	noPop bool

65	61	averageDecorators []decor.AverageDecorator
66	62	ewmaDecorators []decor.EwmaDecorator
67	63	shutdownListeners []decor.ShutdownListener
68		bufP, bufB, bufA *bytes.Buffer
	64	buffers [3]*bytes.Buffer
69	65	filler BarFiller
70	66	middleware func(BarFiller) BarFiller
71	67	extender extenderFunc

76	72	debugOut io.Writer
77	73	}
78	74
	75	type frame struct {
	76	reader io.Reader
	77	lines int
	78	}
	79
79	80	func newBar(container Progress, bs bState) *Bar {
80		logPrefix := fmt.Sprintf("%sbar#%02d ", container.dlogger.Prefix(), bs.id)
81	81	ctx, cancel := context.WithCancel(container.ctx)
82	82
83	83	bar := &Bar{

86	86	toDrop: bs.dropOnComplete,
87	87	noPop: bs.noPop,
88	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),
	89	frameCh: make(chan *frame, 1),
92	90	done: make(chan struct{}),
93	91	cancel: cancel,
94		dlogger: log.New(bs.debugOut, logPrefix, log.Lshortfile),
95	92	}
96	93
97	94	go bar.serve(ctx, bs)

104	101	if r == nil {
105	102	panic("expected non nil io.Reader")
106	103	}
107		return newProxyReader(r, b)
	104	return b.newProxyReader(r)
108	105	}
109	106
110	107	// ID returs id of the bar.

144	141
145	142	// TraverseDecorators traverses all available decorators and calls cb func on each.
146	143	func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) {
	144	done := make(chan struct{})
147	145	select {
148	146	case b.operateState <- func(s *bState) {
149	147	for _, decorators := range [...][]decor.Decorator{

154	152	cb(extractBaseDecorator(d))
155	153	}
156	154	}
157		}:
	155	close(done)
	156	}:
	157	<-done
158	158	case <-b.done:
159	159	}
160	160	}
161	161
162	162	// SetTotal sets total dynamically.
163		// If total is less than or equal to zero it takes progress' current value.
	163	// If total is negative it takes progress' current value.
164	164	func (b *Bar) SetTotal(total int64, triggerComplete bool) {
165	165	select {
166	166	case b.operateState <- func(s *bState) {
167	167	s.triggerComplete = triggerComplete
168		if total <= 0 {
	168	if total < 0 {
169	169	s.total = s.current
170	170	} else {
171	171	s.total = total

173	173	if s.triggerComplete && !s.completed {
174	174	s.current = s.total
175	175	s.completed = true
176		go b.refreshTillShutdown()
	176	go b.forceRefreshIfLastUncompleted()
177	177	}
178	178	}:
179	179	case <-b.done:

185	185	func (b *Bar) SetCurrent(current int64) {
186	186	select {
187	187	case b.operateState <- func(s *bState) {
188		s.iterated = true
189		s.lastN = current - s.current
	188	s.lastIncrement = current - s.current
190	189	s.current = current
191	190	if s.triggerComplete && s.current >= s.total {
192	191	s.current = s.total
193	192	s.completed = true
194		go b.refreshTillShutdown()
	193	go b.forceRefreshIfLastUncompleted()
195	194	}
196	195	}:
197	196	case <-b.done:

210	209
211	210	// IncrInt64 increments progress by amount of n.
212	211	func (b *Bar) IncrInt64(n int64) {
213		select {
214		case b.operateState <- func(s *bState) {
215		s.iterated = true
216		s.lastN = n
	212	if n <= 0 {
	213	return
	214	}
	215	select {
	216	case b.operateState <- func(s *bState) {
	217	s.lastIncrement = n
217	218	s.current += n
218	219	if s.triggerComplete && s.current >= s.total {
219	220	s.current = s.total
220	221	s.completed = true
221		go b.refreshTillShutdown()
	222	go b.forceRefreshIfLastUncompleted()
222	223	}
223	224	}:
224	225	case <-b.done:

232	233	func (b *Bar) DecoratorEwmaUpdate(dur time.Duration) {
233	234	select {
234	235	case b.operateState <- func(s *bState) {
235		ewmaIterationUpdate(false, s, dur)
236		}:
237		case <-b.done:
238		ewmaIterationUpdate(true, b.cacheState, dur)
	236	if s.lastIncrement > 0 {
	237	s.decoratorEwmaUpdate(dur)
	238	s.lastIncrement = 0
	239	} else {
	240	panic("increment required before ewma iteration update")
	241	}
	242	}:
	243	case <-b.done:
	244	if b.cacheState.lastIncrement > 0 {
	245	b.cacheState.decoratorEwmaUpdate(dur)
	246	b.cacheState.lastIncrement = 0
	247	}
239	248	}
240	249	}
241	250

245	254	func (b *Bar) DecoratorAverageAdjust(start time.Time) {
246	255	select {
247	256	case b.operateState <- func(s *bState) {
248		for _, d := range s.averageDecorators {
249		d.AverageAdjust(start)
250		}
	257	s.decoratorAverageAdjust(start)
251	258	}:
252	259	case <-b.done:
253	260	}

257	264	// priority, i.e. bar will be on top. If you don't need to set priority
258	265	// dynamically, better use BarPriority option.
259	266	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.
	267	b.container.UpdateBarPriority(b, priority)
	268	}
	269
	270	// Abort interrupts bar's running goroutine. Abort won't be engaged
	271	// if bar is already in complete state. If drop is true bar will be
	272	// removed as well.
270	273	func (b *Bar) Abort(drop bool) {
271		select {
272		case <-b.done:
273		default:
274		if drop {
275		b.container.dropBar(b)
276		}
	274	done := make(chan struct{})
	275	select {
	276	case b.operateState <- func(s *bState) {
	277	if s.completed {
	278	close(done)
	279	return
	280	}
	281	s.aborted = true
277	282	b.cancel()
	283	// container must be run during lifetime of this inner goroutine
	284	// we control this by done channel declared above
	285	go func() {
	286	if drop {
	287	b.container.dropBar(b)
	288	} else {
	289	var uncompleted int
	290	b.container.traverseBars(func(bar *Bar) bool {
	291	if b != bar && !bar.Completed() {
	292	uncompleted++
	293	return false
	294	}
	295	return true
	296	})
	297	if uncompleted == 0 {
	298	b.container.refreshCh <- time.Now()
	299	}
	300	}
	301	close(done) // release hold of Abort
	302	}()
	303	}:
	304	// guarantee: container is alive during lifetime of this hold
	305	<-done
	306	case <-b.done:
278	307	}
279	308	}
280	309
281	310	// Completed reports whether the bar is in completed state.
282	311	func (b *Bar) Completed() bool {
283		select {
284		case b.operateState <- func(s *bState) { b.completed <- s.completed }:
285		return <-b.completed
	312	result := make(chan bool)
	313	select {
	314	case b.operateState <- func(s *bState) { result <- s.completed }:
	315	return <-result
286	316	case <-b.done:
287	317	return true
288	318	}

295	325	case op := <-b.operateState:
296	326	op(s)
297	327	case <-ctx.Done():
	328	s.decoratorShutdownNotify()
298	329	b.cacheState = s
299	330	close(b.done)
300		// Notifying decorators about shutdown event
301		for _, sl := range s.shutdownListeners {
302		sl.Shutdown()
303		}
304	331	return
305	332	}
306	333	}

314	341	// recovering if user defined decorator panics for example
315	342	if p := recover(); p != nil {
316	343	if b.recoveredPanic == nil {
	344	if s.debugOut != nil {
	345	fmt.Fprintln(s.debugOut, p)
	346	_, _ = s.debugOut.Write(debug.Stack())
	347	}
317	348	s.extender = makePanicExtender(p)
318	349	b.toShutdown = !b.toShutdown
319	350	b.recoveredPanic = p
320	351	}
321		frame, lines := s.extender(nil, s.reqWidth, stat)
322		b.extendedLines = lines
323		b.frameCh <- frame
324		b.dlogger.Println(p)
	352	reader, lines := s.extender(nil, s.reqWidth, stat)
	353	b.frameCh <- &frame{reader, lines + 1}
325	354	}
326	355	s.completeFlushed = s.completed
327	356	}()
328		frame, lines := s.extender(s.draw(stat), s.reqWidth, stat)
329		b.extendedLines = lines
	357	reader, lines := s.extender(s.draw(stat), s.reqWidth, stat)
330	358	b.toShutdown = s.completed && !s.completeFlushed
331		b.frameCh <- frame
	359	b.frameCh <- &frame{reader, lines + 1}
332	360	}:
333	361	case <-b.done:
334	362	s := b.cacheState

337	365	if b.recoveredPanic == nil {
338	366	r = s.draw(stat)
339	367	}
340		frame, lines := s.extender(r, s.reqWidth, stat)
341		b.extendedLines = lines
342		b.frameCh <- frame
	368	reader, lines := s.extender(r, s.reqWidth, stat)
	369	b.frameCh <- &frame{reader, lines + 1}
343	370	}
344	371	}
345	372

358	385	shutdownListeners = append(shutdownListeners, d)
359	386	}
360	387	})
	388	b.hasEwmaDecorators = len(ewmaDecorators) != 0
361	389	select {
362	390	case b.operateState <- func(s *bState) {
363	391	s.averageDecorators = averageDecorators
364	392	s.ewmaDecorators = ewmaDecorators
365	393	s.shutdownListeners = shutdownListeners
366	394	}:
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
	395	case <-b.done:
	396	}
	397	}
	398
	399	func (b *Bar) forceRefreshIfLastUncompleted() {
	400	var uncompleted int
	401	b.container.traverseBars(func(bar *Bar) bool {
	402	if b != bar && !bar.Completed() {
	403	uncompleted++
	404	return false
	405	}
	406	return true
	407	})
	408	if uncompleted == 0 {
	409	for {
	410	select {
	411	case b.container.refreshCh <- time.Now():
	412	case <-b.done:
	413	return
	414	}
378	415	}
379	416	}
380	417	}
381	418
382	419	func (b *Bar) wSyncTable() [][]chan int {
383		select {
384		case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
385		return <-b.syncTableCh
	420	result := make(chan [][]chan int)
	421	select {
	422	case b.operateState <- func(s *bState) { result <- s.wSyncTable() }:
	423	return <-result
386	424	case <-b.done:
387	425	return b.cacheState.wSyncTable()
388	426	}
389	427	}
390	428
391	429	func (s *bState) draw(stat decor.Statistics) io.Reader {
	430	bufP, bufB, bufA := s.buffers[0], s.buffers[1], s.buffers[2]
392	431	nlr := strings.NewReader("\n")
393	432	tw := stat.AvailableWidth
394	433	for _, d := range s.pDecorators {
395	434	str := d.Decor(stat)
396	435	stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
397		s.bufP.WriteString(str)
	436	bufP.WriteString(str)
398	437	}
399	438	if stat.AvailableWidth < 1 {
400		trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufP.String()), tw, "…"))
401		s.bufP.Reset()
	439	trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(bufP.String()), tw, "…"))
	440	bufP.Reset()
402	441	return io.MultiReader(trunc, nlr)
403	442	}
404	443
405	444	if !s.trimSpace && stat.AvailableWidth > 1 {
406	445	stat.AvailableWidth -= 2
407		s.bufB.WriteByte(' ')
408		defer s.bufB.WriteByte(' ')
	446	bufB.WriteByte(' ')
	447	defer bufB.WriteByte(' ')
409	448	}
410	449
411	450	tw = stat.AvailableWidth
412	451	for _, d := range s.aDecorators {
413	452	str := d.Decor(stat)
414	453	stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str))
415		s.bufA.WriteString(str)
	454	bufA.WriteString(str)
416	455	}
417	456	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)
	457	trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(bufA.String()), tw, "…"))
	458	bufA.Reset()
	459	return io.MultiReader(bufP, bufB, trunc, nlr)
	460	}
	461
	462	s.filler.Fill(bufB, s.reqWidth, stat)
	463
	464	return io.MultiReader(bufP, bufB, bufA, nlr)
426	465	}
427	466
428	467	func (s *bState) wSyncTable() [][]chan int {

445	484	table[0] = columns[0:pCount]
446	485	table[1] = columns[pCount : pCount+aCount : pCount+aCount]
447	486	return table
	487	}
	488
	489	func (s bState) decoratorEwmaUpdate(dur time.Duration) {
	490	wg := new(sync.WaitGroup)
	491	for i := 0; i < len(s.ewmaDecorators); i++ {
	492	switch d := s.ewmaDecorators[i]; i {
	493	case len(s.ewmaDecorators) - 1:
	494	d.EwmaUpdate(s.lastIncrement, dur)
	495	default:
	496	wg.Add(1)
	497	go func() {
	498	d.EwmaUpdate(s.lastIncrement, dur)
	499	wg.Done()
	500	}()
	501	}
	502	}
	503	wg.Wait()
	504	}
	505
	506	func (s bState) decoratorAverageAdjust(start time.Time) {
	507	wg := new(sync.WaitGroup)
	508	for i := 0; i < len(s.averageDecorators); i++ {
	509	switch d := s.averageDecorators[i]; i {
	510	case len(s.averageDecorators) - 1:
	511	d.AverageAdjust(start)
	512	default:
	513	wg.Add(1)
	514	go func() {
	515	d.AverageAdjust(start)
	516	wg.Done()
	517	}()
	518	}
	519	}
	520	wg.Wait()
	521	}
	522
	523	func (s bState) decoratorShutdownNotify() {
	524	wg := new(sync.WaitGroup)
	525	for i := 0; i < len(s.shutdownListeners); i++ {
	526	switch d := s.shutdownListeners[i]; i {
	527	case len(s.shutdownListeners) - 1:
	528	d.Shutdown()
	529	default:
	530	wg.Add(1)
	531	go func() {
	532	d.Shutdown()
	533	wg.Done()
	534	}()
	535	}
	536	}
	537	wg.Wait()
448	538	}
449	539
450	540	func newStatistics(tw int, s *bState) decor.Statistics {

455	545	Current: s.current,
456	546	Refill: s.refill,
457	547	Completed: s.completeFlushed,
	548	Aborted: s.aborted,
458	549	}
459	550	}
460	551

465	556	return d
466	557	}
467	558
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	559	func makePanicExtender(p interface{}) extenderFunc {
480	560	pstr := fmt.Sprint(p)
481		stack := debug.Stack()
482		stackLines := bytes.Count(stack, []byte("\n"))
483	561	return func(_ io.Reader, _ int, st decor.Statistics) (io.Reader, int) {
484	562	mr := io.MultiReader(
485	563	strings.NewReader(runewidth.Truncate(pstr, st.AvailableWidth, "…")),
486		strings.NewReader(fmt.Sprintf("\n%#v\n", st)),
487		bytes.NewReader(stack),
	564	strings.NewReader("\n"),
488	565	)
489		return mr, stackLines + 1
490		}
491		}
	566	return mr, 0
	567	}
	568	}

+18

-7

bar_filler.go less more

8	8	// BarFiller interface.
9	9	// Bar (without decorators) renders itself by calling BarFiller's Fill method.
10	10	//
11		// reqWidth is requested width, set by `func WithWidth(int) ContainerOption`.
	11	// reqWidth is requested width set by `func WithWidth(int) ContainerOption`.
12	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	13	//
19	14	type BarFiller interface {
20	15	Fill(w io.Writer, reqWidth int, stat decor.Statistics)
21	16	}
22	17
23	18	// BarFillerBuilder interface.
	19	// Default implementations are:
	20	//
	21	// BarStyle()
	22	// SpinnerStyle()
	23	// NopStyle()
	24	//
24	25	type BarFillerBuilder interface {
25	26	Build() BarFiller
26	27	}
27	28
28		// BarFillerFunc is function type adapter to convert function into BarFiller.
	29	// BarFillerFunc is function type adapter to convert compatible function
	30	// into BarFiller interface.
29	31	type BarFillerFunc func(w io.Writer, reqWidth int, stat decor.Statistics)
30	32
31	33	func (f BarFillerFunc) Fill(w io.Writer, reqWidth int, stat decor.Statistics) {
32	34	f(w, reqWidth, stat)
33	35	}
34	36
	37	// BarFillerBuilderFunc is function type adapter to convert compatible
	38	// function into BarFillerBuilder interface.
	39	type BarFillerBuilderFunc func() BarFiller
	40
	41	func (f BarFillerBuilderFunc) Build() BarFiller {
	42	return f()
	43	}
	44
35	45	// NewBarFiller constructs a BarFiller from provided BarFillerBuilder.
	46	// Deprecated. Prefer using `*Progress.New(...)` directly.
36	47	func NewBarFiller(b BarFillerBuilder) BarFiller {
37	48	return b.Build()
38	49	}

+128

-91

bar_filler_bar.go less more

25	25	Filler(string) BarStyleComposer
26	26	Refiller(string) BarStyleComposer
27	27	Padding(string) BarStyleComposer
28		Tip(...string) BarStyleComposer
	28	TipOnComplete(string) BarStyleComposer
	29	Tip(frames ...string) BarStyleComposer
29	30	Reverse() BarStyleComposer
30	31	}
31	32
32	33	type bFiller struct {
	34	rev bool
33	35	components [components]*component
34	36	tip struct {
35		count uint
36		frames []*component
37		}
38		flush func(dst io.Writer, filling, padding [][]byte)
	37	count uint
	38	onComplete *component
	39	frames []*component
	40	}
39	41	}
40	42
41	43	type component struct {

44	46	}
45	47
46	48	type barStyle struct {
47		lbound string
48		rbound string
49		filler string
50		refiller string
51		padding string
52		tip []string
53		rev bool
	49	lbound string
	50	rbound string
	51	filler string
	52	refiller string
	53	padding string
	54	tipOnComplete string
	55	tipFrames []string
	56	rev bool
54	57	}
55	58
56	59	// BarStyle constructs default bar style which can be altered via
57	60	// BarStyleComposer interface.
58	61	func BarStyle() BarStyleComposer {
59	62	return &barStyle{
60		lbound: "[",
61		rbound: "]",
62		filler: "=",
63		refiller: "+",
64		padding: "-",
65		tip: []string{">"},
	63	lbound: "[",
	64	rbound: "]",
	65	filler: "=",
	66	refiller: "+",
	67	padding: "-",
	68	tipFrames: []string{">"},
66	69	}
67	70	}
68	71

91	94	return s
92	95	}
93	96
94		func (s *barStyle) Tip(tip ...string) BarStyleComposer {
95		if len(tip) != 0 {
96		s.tip = append(s.tip[:0], tip...)
	97	func (s *barStyle) TipOnComplete(tip string) BarStyleComposer {
	98	s.tipOnComplete = tip
	99	return s
	100	}
	101
	102	func (s *barStyle) Tip(frames ...string) BarStyleComposer {
	103	if len(frames) != 0 {
	104	s.tipFrames = append(s.tipFrames[:0], frames...)
97	105	}
98	106	return s
99	107	}

104	112	}
105	113
106	114	func (s *barStyle) Build() BarFiller {
107		bf := new(bFiller)
108		if s.rev {
109		bf.flush = func(dst io.Writer, filling, padding [][]byte) {
110		flush(dst, padding, filling)
111		}
112		} else {
113		bf.flush = flush
114		}
	115	bf := &bFiller{rev: s.rev}
115	116	bf.components[iLbound] = &component{
116	117	width: runewidth.StringWidth(stripansi.Strip(s.lbound)),
117	118	bytes: []byte(s.lbound),

132	133	width: runewidth.StringWidth(stripansi.Strip(s.padding)),
133	134	bytes: []byte(s.padding),
134	135	}
135		bf.tip.frames = make([]*component, len(s.tip))
136		for i, t := range s.tip {
	136	bf.tip.onComplete = &component{
	137	width: runewidth.StringWidth(stripansi.Strip(s.tipOnComplete)),
	138	bytes: []byte(s.tipOnComplete),
	139	}
	140	bf.tip.frames = make([]*component, len(s.tipFrames))
	141	for i, t := range s.tipFrames {
137	142	bf.tip.frames[i] = &component{
138	143	width: runewidth.StringWidth(stripansi.Strip(t)),
139	144	bytes: []byte(t),

145	150	func (s *bFiller) Fill(w io.Writer, width int, stat decor.Statistics) {
146	151	width = internal.CheckRequestedWidth(width, stat.AvailableWidth)
147	152	brackets := s.components[iLbound].width + s.components[iRbound].width
148		if width < brackets {
149		return
150		}
151	153	// don't count brackets as progress
152	154	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
	155	if width < 0 {
	156	return
	157	}
	158
	159	ow := optimisticWriter(w)
	160	ow(s.components[iLbound].bytes)
	161	defer ow(s.components[iRbound].bytes)
	162
	163	if width == 0 {
	164	return
	165	}
	166
	167	var filling [][]byte
	168	var padding [][]byte
	169	var tip *component
	170	var filled int
	171	var refWidth int
	172	curWidth := int(internal.PercentageRound(stat.Total, stat.Current, uint(width)))
	173
	174	if stat.Current >= stat.Total {
	175	tip = s.tip.onComplete
	176	} else {
	177	tip = s.tip.frames[s.tip.count%uint(len(s.tip.frames))]
	178	}
	179
	180	if curWidth > 0 {
	181	filling = append(filling, tip.bytes)
	182	filled += tip.width
165	183	s.tip.count++
166	184	}
167	185
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		}
	186	if stat.Refill > 0 {
	187	refWidth = int(internal.PercentageRound(stat.Total, stat.Refill, uint(width)))
173	188	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
	189	refWidth += curWidth
	190	}
	191
	192	for filled < curWidth {
	193	if curWidth-filled >= s.components[iFiller].width {
	194	filling = append(filling, s.components[iFiller].bytes)
	195	if s.components[iFiller].width == 0 {
	196	break
	197	}
	198	filled += s.components[iFiller].width
	199	} else {
	200	filling = append(filling, []byte("…"))
	201	filled++
	202	}
	203	}
	204
	205	for filled < refWidth {
	206	if refWidth-filled >= s.components[iRefiller].width {
	207	filling = append(filling, s.components[iRefiller].bytes)
	208	if s.components[iRefiller].width == 0 {
	209	break
	210	}
	211	filled += s.components[iRefiller].width
	212	} else {
	213	filling = append(filling, []byte("…"))
	214	filled++
	215	}
	216	}
	217
193	218	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	219	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) {
	220	if padWidth >= s.components[iPadding].width {
	221	padding = append(padding, s.components[iPadding].bytes)
	222	if s.components[iPadding].width == 0 {
	223	break
	224	}
	225	padWidth -= s.components[iPadding].width
	226	} else {
	227	padding = append(padding, []byte("…"))
	228	padWidth--
	229	}
	230	}
	231
	232	if s.rev {
	233	flush(ow, padding, filling)
	234	} else {
	235	flush(ow, filling, padding)
	236	}
	237	}
	238
	239	func flush(ow func([]byte), filling, padding [][]byte) {
212	240	for i := len(filling) - 1; i >= 0; i-- {
213		dst.Write(filling[i])
	241	ow(filling[i])
214	242	}
215	243	for i := 0; i < len(padding); i++ {
216		dst.Write(padding[i])
217		}
218		}
	244	ow(padding[i])
	245	}
	246	}
	247
	248	func optimisticWriter(w io.Writer) func([]byte) {
	249	return func(p []byte) {
	250	_, err := w.Write(p)
	251	if err != nil {
	252	panic(err)
	253	}
	254	}
	255	}

+14

-0

bar_filler_nop.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4
	5	"github.com/vbauerster/mpb/v7/decor"
	6	)
	7
	8	// NopStyle provides BarFillerBuilder which builds NOP BarFiller.
	9	func NopStyle() BarFillerBuilder {
	10	return BarFillerBuilderFunc(func() BarFiller {
	11	return BarFillerFunc(func(io.Writer, int, decor.Statistics) {})
	12	})
	13	}

-3

bar_filler_spinner.go less more

72	72	return
73	73	}
74	74
	75	var err error
75	76	rest := width - frameWidth
76	77	switch s.position {
77	78	case positionLeft:
78		io.WriteString(w, frame+strings.Repeat(" ", rest))
	79	_, err = io.WriteString(w, frame+strings.Repeat(" ", rest))
79	80	case positionRight:
80		io.WriteString(w, strings.Repeat(" ", rest)+frame)
	81	_, err = io.WriteString(w, strings.Repeat(" ", rest)+frame)
81	82	default:
82	83	str := strings.Repeat(" ", rest/2) + frame + strings.Repeat(" ", rest/2+rest%2)
83		io.WriteString(w, str)
	84	_, err = io.WriteString(w, str)
	85	}
	86	if err != nil {
	87	panic(err)
84	88	}
85	89	s.count++
86	90	}

+21

-7

bar_option.go less more

4	4	"io"
5	5
6	6	"github.com/vbauerster/mpb/v7/decor"
7		"github.com/vbauerster/mpb/v7/internal"
8	7	)
9	8
10	9	// BarOption is a func option to alter default behavior of a bar.
11	10	type BarOption func(*bState)
	11
	12	func skipNil(decorators []decor.Decorator) (filtered []decor.Decorator) {
	13	for _, d := range decorators {
	14	if d != nil {
	15	filtered = append(filtered, d)
	16	}
	17	}
	18	return
	19	}
12	20
13	21	func (s bState) addDecorators(dest []decor.Decorator, decorators ...decor.Decorator) {
14	22	type mergeWrapper interface {

25	33	// AppendDecorators let you inject decorators to the bar's right side.
26	34	func AppendDecorators(decorators ...decor.Decorator) BarOption {
27	35	return func(s *bState) {
28		s.addDecorators(&s.aDecorators, decorators...)
	36	s.addDecorators(&s.aDecorators, skipNil(decorators)...)
29	37	}
30	38	}
31	39
32	40	// PrependDecorators let you inject decorators to the bar's left side.
33	41	func PrependDecorators(decorators ...decor.Decorator) BarOption {
34	42	return func(s *bState) {
35		s.addDecorators(&s.pDecorators, decorators...)
	43	s.addDecorators(&s.pDecorators, skipNil(decorators)...)
36	44	}
37	45	}
38	46

80	88	return BarFillerMiddleware(func(base BarFiller) BarFiller {
81	89	return BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) {
82	90	if st.Completed {
83		io.WriteString(w, message)
	91	_, err := io.WriteString(w, message)
	92	if err != nil {
	93	panic(err)
	94	}
84	95	} else {
85	96	base.Fill(w, reqWidth, st)
86	97	}

137	148	}
138	149	}
139	150
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))
	151	// BarOptional will invoke provided option only when cond is true.
	152	func BarOptional(option BarOption, cond bool) BarOption {
	153	if cond {
	154	return option
	155	}
	156	return nil
143	157	}
144	158
145	159	// BarOptOn will invoke provided option only when higher order predicate

+10

-7

bar_test.go less more

62	62	till := 30
63	63	refiller := "+"
64	64
65		bar := p.Add(int64(total), mpb.NewBarFiller(mpb.BarStyle().Refiller(refiller)), mpb.BarFillerTrim())
	65	bar := p.New(int64(total), mpb.BarStyle().Refiller(refiller), mpb.BarFillerTrim())
66	66
67	67	bar.SetRefill(int64(till))
68	68	bar.IncrBy(till)

151	151	bs.Tip(string(runes[2]))
152	152	bs.Padding(string(runes[3]))
153	153	bs.Rbound(string(runes[4]))
154		bar := p.Add(int64(total), mpb.NewBarFiller(bs), mpb.BarFillerTrim())
	154	bar := p.New(int64(total), bs, mpb.BarFillerTrim())
155	155
156	156	for i := 0; i < total; i++ {
157	157	bar.Increment()

254	254	}
255	255
256	256	func TestDecorStatisticsAvailableWidth(t *testing.T) {
	257	total := 100
	258	down := make(chan struct{})
	259	checkDone := make(chan struct{})
257	260	td1 := func(s decor.Statistics) string {
258	261	if s.AvailableWidth != 80 {
259	262	t.Errorf("expected AvailableWidth %d got %d\n", 80, s.AvailableWidth)
260	263	}
261	264	return fmt.Sprintf("\x1b[31;1;4m%s\x1b[0m", strings.Repeat("0", 20))
262	265	}
263		checkDone := make(chan struct{})
264	266	td2 := func(s decor.Statistics) string {
265	267	defer func() {
266		checkDone <- struct{}{}
	268	select {
	269	case checkDone <- struct{}{}:
	270	default:
	271	}
267	272	}()
268	273	if s.AvailableWidth != 40 {
269	274	t.Errorf("expected AvailableWidth %d got %d\n", 40, s.AvailableWidth)
270	275	}
271	276	return ""
272	277	}
273		total := 100
274		down := make(chan struct{})
275	278	p := mpb.New(
276	279	mpb.WithWidth(100),
277	280	mpb.WithShutdownNotifier(down),

292	295	for {
293	296	select {
294	297	case <-checkDone:
295		bar.Abort(false)
	298	bar.Abort(true)
296	299	case <-down:
297	300	return
298	301	}

+43

-28

barbench_test.go less more

0	0	package mpb
1	1
2	2	import (
3		"io/ioutil"
	3	"sync"
4	4	"testing"
5
6		"github.com/vbauerster/mpb/v7/decor"
7	5	)
8	6
9		func BenchmarkIncrSingleBar(b *testing.B) {
10		p := New(WithOutput(ioutil.Discard), WithWidth(80))
11		bar := p.AddBar(int64(b.N))
12		for i := 0; i < b.N; i++ {
13		bar.Increment()
14		}
	7	const total = 1000
	8
	9	func BenchmarkIncrementOneBar(b *testing.B) {
	10	benchBody(1, b)
15	11	}
16	12
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		}
	13	func BenchmarkIncrementTwoBars(b *testing.B) {
	14	benchBody(2, b)
23	15	}
24	16
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		}
	17	func BenchmarkIncrementThreeBars(b *testing.B) {
	18	benchBody(3, b)
31	19	}
32	20
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		)
	21	func BenchmarkIncrementFourBars(b *testing.B) {
	22	benchBody(4, b)
	23	}
	24
	25	func benchBody(n int, b *testing.B) {
	26	p := New(WithOutput(nil), WithWidth(80))
	27	wg := new(sync.WaitGroup)
	28	b.ResetTimer()
39	29	for i := 0; i < b.N; i++ {
40		bar.Increment()
	30	for j := 0; j < n; j++ {
	31	switch j {
	32	case n - 1:
	33	bar := p.AddBar(total)
	34	for c := 0; c < total; c++ {
	35	bar.Increment()
	36	}
	37	if !bar.Completed() {
	38	b.Fail()
	39	}
	40	default:
	41	wg.Add(1)
	42	go func() {
	43	bar := p.AddBar(total)
	44	for c := 0; c < total; c++ {
	45	bar.Increment()
	46	}
	47	if !bar.Completed() {
	48	b.Fail()
	49	}
	50	wg.Done()
	51	}()
	52	}
	53	}
	54	wg.Wait()
41	55	}
	56	p.Wait()
42	57	}

+11

-6

container_option.go less more

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

61	59	// have been rendered.
62	60	func WithShutdownNotifier(ch chan struct{}) ContainerOption {
63	61	return func(s *pState) {
64		s.shutdownNotifier = ch
	62	select {
	63	case <-ch:
	64	default:
	65	s.shutdownNotifier = ch
	66	}
65	67	}
66	68	}
67	69

96	98	}
97	99	}
98	100
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))
	101	// ContainerOptional will invoke provided option only when cond is true.
	102	func ContainerOptional(option ContainerOption, cond bool) ContainerOption {
	103	if cond {
	104	return option
	105	}
	106	return nil
102	107	}
103	108
104	109	// ContainerOptOn will invoke provided option only when higher order

-4

cwriter/cuuAndEd_construction_bench_test.go less more

17	17	func BenchmarkWithJoin(b *testing.B) {
18	18	bCuuAndEd := [][]byte{[]byte("\x1b["), []byte("A\x1b[J")}
19	19	for i := 0; i < b.N; i++ {
20		ioutil.Discard.Write(bytes.Join(bCuuAndEd, []byte(strconv.Itoa(4))))
	20	_, _ = ioutil.Discard.Write(bytes.Join(bCuuAndEd, []byte(strconv.Itoa(4))))
21	21	}
22	22	}
23	23

25	25	escOpen := []byte("\x1b[")
26	26	cuuAndEd := []byte("A\x1b[J")
27	27	for i := 0; i < b.N; i++ {
28		ioutil.Discard.Write(append(strconv.AppendInt(escOpen, 4, 10), cuuAndEd...))
	28	_, _ = ioutil.Discard.Write(append(strconv.AppendInt(escOpen, 4, 10), cuuAndEd...))
29	29	}
30	30	}
31	31
32	32	func BenchmarkWithCopy(b *testing.B) {
33	33	w := New(ioutil.Discard)
34		w.lineCount = 4
	34	w.lines = 4
35	35	for i := 0; i < b.N; i++ {
36		w.ansiCuuAndEd()
	36	_ = w.ansiCuuAndEd()
37	37	}
38	38	}

-8

cwriter/writer.go less more

21	21	type Writer struct {
22	22	out io.Writer
23	23	buf bytes.Buffer
24		lineCount int
	24	lines int
25	25	fd int
26	26	isTerminal bool
27	27	}

37	37	}
38	38
39	39	// Flush flushes the underlying buffer.
40		func (w *Writer) Flush(lineCount int) (err error) {
	40	func (w *Writer) Flush(lines int) (err error) {
41	41	// some terminals interpret 'cursor up 0' as 'cursor up 1'
42		if w.lineCount > 0 {
	42	if w.lines > 0 {
43	43	err = w.clearLines()
44	44	if err != nil {
45	45	return
46	46	}
47	47	}
48		w.lineCount = lineCount
	48	w.lines = lines
49	49	_, err = w.buf.WriteTo(w.out)
50	50	return
51	51	}

75	75	return tw, err
76	76	}
77	77
78		func (w *Writer) ansiCuuAndEd() (err error) {
	78	func (w *Writer) ansiCuuAndEd() error {
79	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
	80	buf = strconv.AppendInt(buf[:copy(buf, escOpen)], int64(w.lines), 10)
	81	_, err := w.out.Write(append(buf, cuuAndEd...))
	82	return err
83	83	}

-2

cwriter/writer_windows.go less more

25	25	return err
26	26	}
27	27
28		info.CursorPosition.Y -= int16(w.lineCount)
	28	info.CursorPosition.Y -= int16(w.lines)
29	29	if info.CursorPosition.Y < 0 {
30	30	info.CursorPosition.Y = 0
31	31	}

39	39	X: info.Window.Left,
40	40	Y: info.CursorPosition.Y,
41	41	}
42		count := uint32(info.Size.X) * uint32(w.lineCount)
	42	count := uint32(info.Size.X) * uint32(w.lines)
43	43	_, _, _ = procFillConsoleOutputCharacter.Call(
44	44	uintptr(w.fd),
45	45	uintptr(' '),

-27

debian/changelog less more

0		golang-github-vbauerster-mpb (7.0.3-1) unstable; urgency=medium
	0	golang-github-vbauerster-mpb (7.3.2-1) unstable; urgency=medium
1	1
2		* New upstream release
	2	* Team upload.
	3	* New upstream version
	4	* Standards-Version: 4.6.0 (routine-update)
	5	* debhelper-compat 13 (routine-update)
	6	* Rules-Requires-Root: no (routine-update)
	7	* (Build-)Depends: golang-github-mattn-go-runewidth-dev
3	8
4		-- Reinhard Tartler <siretart@tauware.de> Sat, 28 Aug 2021 22:10:19 +0200
5
6		golang-github-vbauerster-mpb (6.0.3-2) unstable; urgency=medium
7
8		* Upload to unstable
9
10		-- Reinhard Tartler <siretart@tauware.de> Sat, 28 Aug 2021 21:11:02 +0200
11
12		golang-github-vbauerster-mpb (6.0.3-1) experimental; urgency=medium
13
14		* Team upload
15		* Upgrade to version v6.0.3, Closes: #987511)
16		Breaking changes (cf. https://github.com/vbauerster/mpb/releases):
17		Removed:
18		func BarStyle(style string) BarOption
19		func BarReverse() BarOption
20		func SpinnerStyle(frames []string) BarOption
21		func TrimSpace() BarOption
22		To set bar style use BarFiller constructors.
23		.
24		Added:
25		func ContainerOptional(option ContainerOption, pick bool) ContainerOption
26		func BarOptional(option BarOption, pick bool) BarOption
27
28		-- Reinhard Tartler <siretart@tauware.de> Sun, 25 Apr 2021 11:32:28 -0400
	9	-- Andreas Tille <tille@debian.org> Wed, 26 Jan 2022 20:33:53 +0100
29	10
30	11	golang-github-vbauerster-mpb (5.0.3-2) unstable; urgency=low
31	12

-4

debian/control less more

3	3	Maintainer: Debian Go Packaging Team <team+pkg-go@tracker.debian.org>
4	4	Uploaders: Reinhard Tartler <siretart@tauware.de>,
5	5	Dmitry Smirnov <onlyjob@debian.org>,
6		Build-Depends: debhelper-compat (= 12),
	6	Build-Depends: debhelper-compat (= 13),
7	7	dh-golang,
8	8	golang-any,
9	9	golang-github-acarl005-stripansi-dev,
10	10	golang-github-mattn-go-isatty-dev,
11	11	golang-github-mattn-go-runewidth-dev,
12		golang-github-rivo-uniseg-dev,
13	12	golang-github-vividcortex-ewma-dev,
14		Standards-Version: 4.5.0
	13	golang-golang-x-crypto-dev
	14	Standards-Version: 4.6.0
15	15	Homepage: https://github.com/vbauerster/mpb
	16	Rules-Requires-Root: no
16	17	Vcs-Browser: https://salsa.debian.org/go-team/packages/golang-github-vbauerster-mpb
17	18	Vcs-Git: https://salsa.debian.org/go-team/packages/golang-github-vbauerster-mpb.git
18	19	XS-Go-Import-Path: github.com/vbauerster/mpb

24	25	golang-github-acarl005-stripansi-dev,
25	26	golang-github-mattn-go-isatty-dev,
26	27	golang-github-mattn-go-runewidth-dev,
27		golang-github-rivo-uniseg-dev,
28	28	golang-github-vividcortex-ewma-dev,
	29	golang-golang-x-crypto-dev
29	30	Description: multi progress bar for Go cli applications
30	31	mpb is a golang library for rendering progress bars in terminal
31	32	applications.

-0

debian/gitlab-ci.yml less more

	0	# auto-generated, DO NOT MODIFY.
	1	# The authoritative copy of this file lives at:
	2	# https://salsa.debian.org/go-team/infra/pkg-go-tools/blob/master/config/gitlabciyml.go
	3	---
	4	include:
	5	- https://salsa.debian.org/go-team/infra/pkg-go-tools/-/raw/master/pipeline/test-archive.yml

-0

decor/decorator.go less more

52	52	Current int64
53	53	Refill int64
54	54	Completed bool
	55	Aborted bool
55	56	}
56	57
57	58	// Decorator interface.

-0

decor/merge.go less more

16	16	// +----+--------+---------+--------+
17	17	//
18	18	func Merge(decorator Decorator, placeholders ...WC) Decorator {
	19	if decorator == nil {
	20	return nil
	21	}
19	22	if _, ok := decorator.Sync(); !ok \|\| len(placeholders) == 0 {
20	23	return decorator
21	24	}

+41

-0

decor/on_abort.go less more

	0	package decor
	1
	2	// OnAbort returns decorator, which wraps provided decorator with sole
	3	// purpose to display provided message on abort event. It has no effect
	4	// if bar.Abort(drop bool) is called with true argument.
	5	//
	6	// `decorator` Decorator to wrap
	7	//
	8	// `message` message to display on abort event
	9	//
	10	func OnAbort(decorator Decorator, message string) Decorator {
	11	if decorator == nil {
	12	return nil
	13	}
	14	d := &onAbortWrapper{
	15	Decorator: decorator,
	16	msg: message,
	17	}
	18	if md, ok := decorator.(*mergeDecorator); ok {
	19	d.Decorator, md.Decorator = md.Decorator, d
	20	return md
	21	}
	22	return d
	23	}
	24
	25	type onAbortWrapper struct {
	26	Decorator
	27	msg string
	28	}
	29
	30	func (d *onAbortWrapper) Decor(s Statistics) string {
	31	if s.Aborted {
	32	wc := d.GetConf()
	33	return wc.FormatMsg(d.msg)
	34	}
	35	return d.Decorator.Decor(s)
	36	}
	37
	38	func (d *onAbortWrapper) Base() Decorator {
	39	return d.Decorator
	40	}

-1

decor/on_complete.go less more

0	0	package decor
1	1
2		// OnComplete returns decorator, which wraps provided decorator, with
	2	// OnComplete returns decorator, which wraps provided decorator with
3	3	// sole purpose to display provided message on complete event.
4	4	//
5	5	// `decorator` Decorator to wrap

7	7	// `message` message to display on complete event
8	8	//
9	9	func OnComplete(decorator Decorator, message string) Decorator {
	10	if decorator == nil {
	11	return nil
	12	}
10	13	d := &onCompleteWrapper{
11	14	Decorator: decorator,
12	15	msg: message,

+27

-0

decor/on_condition.go less more

	0	package decor
	1
	2	// OnPredicate returns decorator if predicate evaluates to true.
	3	//
	4	// `decorator` Decorator
	5	//
	6	// `predicate` func() bool
	7	//
	8	func OnPredicate(decorator Decorator, predicate func() bool) Decorator {
	9	if predicate() {
	10	return decorator
	11	}
	12	return nil
	13	}
	14
	15	// OnCondition returns decorator if condition is true.
	16	//
	17	// `decorator` Decorator
	18	//
	19	// `cond` bool
	20	//
	21	func OnCondition(decorator Decorator, cond bool) Decorator {
	22	if cond {
	23	return decorator
	24	}
	25	return nil
	26	}

+12

-0

decor/optimistic_string_writer.go less more

	0	package decor
	1
	2	import "io"
	3
	4	func optimisticStringWriter(w io.Writer) func(string) {
	5	return func(s string) {
	6	_, err := io.WriteString(w, s)
	7	if err != nil {
	8	panic(err)
	9	}
	10	}
	11	}

-5

decor/percentage.go less more

1	1
2	2	import (
3	3	"fmt"
4		"io"
5	4	"strconv"
6	5
7	6	"github.com/vbauerster/mpb/v7/internal"

23	22	}
24	23	}
25	24
26		io.WriteString(st, strconv.FormatFloat(float64(s), 'f', prec, 64))
27
	25	osw := optimisticStringWriter(st)
	26	osw(strconv.FormatFloat(float64(s), 'f', prec, 64))
28	27	if st.Flag(' ') {
29		io.WriteString(st, " ")
	28	osw(" ")
30	29	}
31		io.WriteString(st, "%")
	30	osw("%")
32	31	}
33	32
34	33	// Percentage returns percentage decorator. It's a wrapper of NewPercentage.

+10

-12

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

46	44	unit = _iMiB
47	45	case self < _iTiB:
48	46	unit = _iGiB
49		case self <= math.MaxInt64:
	47	default:
50	48	unit = _iTiB
51	49	}
52	50
53		io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
54
	51	osw := optimisticStringWriter(st)
	52	osw(strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
55	53	if st.Flag(' ') {
56		io.WriteString(st, " ")
	54	osw(" ")
57	55	}
58		io.WriteString(st, unit.String())
	56	osw(unit.String())
59	57	}
60	58
61	59	const (

95	93	unit = _MB
96	94	case self < _TB:
97	95	unit = _GB
98		case self <= math.MaxInt64:
	96	default:
99	97	unit = _TB
100	98	}
101	99
102		io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
103
	100	osw := optimisticStringWriter(st)
	101	osw(strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
104	102	if st.Flag(' ') {
105		io.WriteString(st, " ")
	103	osw(" ")
106	104	}
107		io.WriteString(st, unit.String())
	105	osw(unit.String())
108	106	}

-2

decor/speed.go less more

1	1
2	2	import (
3	3	"fmt"
4		"io"
5	4	"math"
6	5	"time"
7	6

23	22
24	23	func (self *speedFormatter) Format(st fmt.State, verb rune) {
25	24	self.Formatter.Format(st, verb)
26		io.WriteString(st, "/s")
	25	optimisticStringWriter(st)("/s")
27	26	}
28	27
29	28	// EwmaSpeed exponential-weighted-moving-average based speed decorator.

+1113

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

413	1413	}
414	1414
415	1415	func newTestState(filler BarFiller) *bState {
416		s := &bState{
	1416	bs := &bState{
417	1417	filler: filler,
418		bufP: new(bytes.Buffer),
419		bufB: new(bytes.Buffer),
420		bufA: new(bytes.Buffer),
421	1418	}
422		return s
	1419	for i := 0; i < len(bs.buffers); i++ {
	1420	bs.buffers[i] = bytes.NewBuffer(make([]byte, 0, 512))
	1421	}
	1422	return bs
423	1423	}

-5

example_test.go less more

16	16
17	17	total := 100
18	18	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("╟")),
	19	// create a single bar, which will inherit container's width
	20	bar := p.New(int64(total),
	21	// BarFillerBuilder with custom style
	22	mpb.BarStyle().Lbound("╢").Filler("▌").Tip("▌").Padding("░").Rbound("╟"),
23	23	mpb.PrependDecorators(
24	24	// display our name with one space on the right
25	25	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),

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

-1

go.mod less more

3	3	github.com/VividCortex/ewma v1.2.0
4	4	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
5	5	github.com/mattn/go-runewidth v0.0.13
6		golang.org/x/sys v0.0.0-20210616094352-59db8d763f22
	6	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9
7	7	)
8	8
9	9	go 1.14

-2

go.sum less more

5	5	github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
6	6	github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
7	7	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=
	8	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
	9	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

-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

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

-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		}

+64

-36

progress.go less more

5	5	"context"
6	6	"fmt"
7	7	"io"
8		"io/ioutil"
9		"log"
10	8	"math"
11	9	"os"
12	10	"sync"

18	16
19	17	const (
20	18	// default RefreshRate
21		prr = 120 * time.Millisecond
	19	prr = 150 * time.Millisecond
22	20	)
23	21
24	22	// Progress represents a container that renders one or more progress

32	30	done chan struct{}
33	31	refreshCh chan time.Time
34	32	once sync.Once
35		dlogger *log.Logger
36	33	}
37	34
38	35	// pState holds bars in its priorityQueue. It gets passed to

74	71	rr: prr,
75	72	parkedBars: make(map[Bar]Bar),
76	73	output: os.Stdout,
77		debugOut: ioutil.Discard,
78	74	}
79	75
80	76	for _, opt := range options {

90	86	bwg: new(sync.WaitGroup),
91	87	operateState: make(chan func(*pState)),
92	88	done: make(chan struct{}),
93		dlogger: log.New(s.debugOut, "[mpb] ", log.Lshortfile),
94	89	}
95	90
96	91	p.cwg.Add(1)

98	93	return p
99	94	}
100	95
101		// AddBar creates a bar with default bar filler. Different filler can
102		// be chosen and applied via `Progress.Add(...) Bar` method.
	96	// AddBar creates a bar with default bar filler.
103	97	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.
	98	return p.New(total, BarStyle(), options...)
	99	}
	100
	101	// AddSpinner creates a bar with default spinner filler.
110	102	func (p Progress) AddSpinner(total int64, options ...BarOption) Bar {
111		return p.Add(total, NewBarFiller(SpinnerStyle()), options...)
	103	return p.New(total, SpinnerStyle(), options...)
	104	}
	105
	106	// New creates a bar with provided BarFillerBuilder.
	107	func (p Progress) New(total int64, builder BarFillerBuilder, options ...BarOption) Bar {
	108	return p.Add(total, builder.Build(), options...)
112	109	}
113	110
114	111	// Add creates a bar which renders itself by provided filler.

116	113	// Panics if Progress instance is done, i.e. called after Progress.Wait().
117	114	func (p Progress) Add(total int64, filler BarFiller, options ...BarOption) Bar {
118	115	if filler == nil {
119		filler = BarFillerFunc(func(io.Writer, int, decor.Statistics) {})
	116	filler = NopStyle().Build()
120	117	}
121	118	p.bwg.Add(1)
122	119	result := make(chan *Bar)

156	153	}
157	154	}
158	155
159		func (p Progress) setBarPriority(b Bar, priority int) {
	156	func (p Progress) traverseBars(cb func(b Bar) bool) {
	157	done := make(chan struct{})
	158	select {
	159	case p.operateState <- func(s *pState) {
	160	for i := 0; i < s.bHeap.Len(); i++ {
	161	bar := s.bHeap[i]
	162	if !cb(bar) {
	163	break
	164	}
	165	}
	166	close(done)
	167	}:
	168	<-done
	169	case <-p.done:
	170	}
	171	}
	172
	173	// UpdateBarPriority same as *Bar.SetPriority(int).
	174	func (p Progress) UpdateBarPriority(b Bar, priority int) {
160	175	select {
161	176	case p.operateState <- func(s *pState) {
162	177	if b.index < 0 {

169	184	}
170	185	}
171	186
172		// UpdateBarPriority same as *Bar.SetPriority(int).
173		func (p Progress) UpdateBarPriority(b Bar, priority int) {
174		p.setBarPriority(b, priority)
175		}
176
177	187	// BarCount returns bars count.
178	188	func (p *Progress) BarCount() int {
179		result := make(chan int, 1)
	189	result := make(chan int)
180	190	select {
181	191	case p.operateState <- func(s *pState) { result <- s.bHeap.Len() }:
182	192	return <-result

218	228	op(s)
219	229	case <-p.refreshCh:
220	230	if err := s.render(cw); err != nil {
221		p.dlogger.Println(err)
	231	if s.debugOut != nil {
	232	_, e := fmt.Fprintln(s.debugOut, err)
	233	if e != nil {
	234	panic(err)
	235	}
	236	} else {
	237	panic(err)
	238	}
222	239	}
223	240	case <-s.shutdownNotifier:
224		if s.heapUpdated {
	241	for s.heapUpdated {
225	242	if err := s.render(cw); err != nil {
226		p.dlogger.Println(err)
	243	if s.debugOut != nil {
	244	_, e := fmt.Fprintln(s.debugOut, err)
	245	if e != nil {
	246	panic(err)
	247	}
	248	} else {
	249	panic(err)
	250	}
227	251	}
228	252	}
229	253	return

290	314	}
291	315
292	316	func (s pState) flush(cw cwriter.Writer) error {
293		var lineCount int
294		bm := make(map[*Bar]struct{}, s.bHeap.Len())
	317	var totalLines int
	318	bm := make(map[*Bar]int, s.bHeap.Len())
295	319	for s.bHeap.Len() > 0 {
296	320	b := heap.Pop(&s.bHeap).(*Bar)
297		cw.ReadFrom(<-b.frameCh)
	321	frame := <-b.frameCh
	322	_, err := cw.ReadFrom(frame.reader)
	323	if err != nil {
	324	return err
	325	}
298	326	if b.toShutdown {
299	327	if b.recoveredPanic != nil {
300	328	s.barShutdownQueue = append(s.barShutdownQueue, b)

307	335	}()
308	336	}
309	337	}
310		lineCount += b.extendedLines + 1
311		bm[b] = struct{}{}
	338	bm[b] = frame.lines
	339	totalLines += frame.lines
312	340	}
313	341
314	342	for _, b := range s.barShutdownQueue {

319	347	b.toDrop = true
320	348	}
321	349	if s.popCompleted && !b.noPop {
322		lineCount -= b.extendedLines + 1
	350	totalLines -= bm[b]
323	351	b.toDrop = true
324	352	}
325	353	if b.toDrop {

334	362	heap.Push(&s.bHeap, b)
335	363	}
336	364
337		return cw.Flush(lineCount)
	365	return cw.Flush(totalLines)
338	366	}
339	367
340	368	func (s *pState) updateSyncMatrix() {

385	413	bs.priority = -(math.MaxInt32 - s.idCount)
386	414	}
387	415
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))
	416	for i := 0; i < len(bs.buffers); i++ {
	417	bs.buffers[i] = bytes.NewBuffer(make([]byte, 0, 512))
	418	}
391	419
392	420	return bs
393	421	}

+36

-30

progress_test.go less more

68	68	wg.Wait()
69	69	count := p.BarCount()
70	70	if count != 2 {
71		t.Errorf("BarCount want: %q, got: %q\n", 2, count)
	71	t.Errorf("BarCount want: %d, got: %d\n", 2, count)
72	72	}
73	73	bars[1].Abort(true)
74	74	bars[2].Abort(true)

76	76	}
77	77
78	78	func TestWithContext(t *testing.T) {
	79	shutdown := make(chan struct{})
79	80	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		)
	81	p := mpb.NewWithContext(ctx, mpb.WithShutdownNotifier(shutdown), mpb.WithOutput(ioutil.Discard))
86	82
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		}
	83	start := make(chan struct{})
	84	done := make(chan struct{})
	85	fail := make(chan struct{})
	86	bar := p.AddBar(0) // never complete bar
	87	go func() {
	88	close(start)
	89	for !bar.Completed() {
	90	bar.Increment()
	91	time.Sleep(randomDuration(100 * time.Millisecond))
	92	}
	93	close(done)
	94	}()
100	95
101		time.Sleep(50 * time.Millisecond)
	96	go func() {
	97	select {
	98	case <-done:
	99	p.Wait()
	100	case <-time.After(150 * time.Millisecond):
	101	close(fail)
	102	}
	103	}()
	104
	105	<-start
102	106	cancel()
103
104		p.Wait()
105	107	select {
106	108	case <-shutdown:
107		case <-time.After(100 * time.Millisecond):
108		t.Error("Progress didn't stop")
	109	case <-fail:
	110	t.Error("Progress didn't shutdown")
109	111	}
110	112	}
111	113

126	128	mpb.MaxWidthDistributor = makeWrapper(mpb.MaxWidthDistributor, start, end)
127	129
128	130	total := 80
129		numBars := 3
	131	numBars := 6
130	132	p := mpb.New(mpb.WithOutput(ioutil.Discard))
131	133	for i := 0; i < numBars; i++ {
132	134	bar := p.AddBar(int64(total),

140	142	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
141	143	for i := 0; i < total; i++ {
142	144	start := time.Now()
143		if bar.ID() >= numBars-1 && i >= 42 {
144		bar.Abort(true)
	145	if id := bar.ID(); id > 1 && i >= 42 {
	146	if id&1 == 1 {
	147	bar.Abort(true)
	148	} else {
	149	bar.Abort(false)
	150	}
145	151	}
146		time.Sleep((time.Duration(rng.Intn(10)+1) * (10 * time.Millisecond)) / 2)
147		bar.Increment()
	152	time.Sleep((time.Duration(rng.Intn(10)+1) * (50 * time.Millisecond)) / 2)
	153	bar.IncrInt64(rand.Int63n(5) + 1)
148	154	bar.DecoratorEwmaUpdate(time.Since(start))
149	155	}
150	156	}()

+28

-32

proxyreader.go less more

10	10	bar *Bar
11	11	}
12	12
13		func (x *proxyReader) Read(p []byte) (int, error) {
	13	func (x proxyReader) Read(p []byte) (int, error) {
14	14	n, err := x.ReadCloser.Read(p)
15	15	x.bar.IncrBy(n)
16	16	if err == io.EOF {
17		go x.bar.SetTotal(0, true)
	17	go x.bar.SetTotal(-1, true)
18	18	}
19	19	return n, err
20	20	}
21	21
22	22	type proxyWriterTo struct {
23		io.ReadCloser // *proxyReader
24		wt io.WriterTo
25		bar *Bar
	23	proxyReader
	24	wt io.WriterTo
26	25	}
27	26
28		func (x *proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	27	func (x proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
29	28	n, err := x.wt.WriteTo(w)
30	29	x.bar.IncrInt64(n)
31	30	if err == io.EOF {
32		go x.bar.SetTotal(0, true)
	31	go x.bar.SetTotal(-1, true)
33	32	}
34	33	return n, err
35	34	}
36	35
37	36	type ewmaProxyReader struct {
38		io.ReadCloser // *proxyReader
39		bar *Bar
40		iT time.Time
	37	proxyReader
41	38	}
42	39
43		func (x *ewmaProxyReader) Read(p []byte) (int, error) {
44		n, err := x.ReadCloser.Read(p)
	40	func (x ewmaProxyReader) Read(p []byte) (int, error) {
	41	start := time.Now()
	42	n, err := x.proxyReader.Read(p)
45	43	if n > 0 {
46		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
47		x.iT = time.Now()
	44	x.bar.DecoratorEwmaUpdate(time.Since(start))
48	45	}
49	46	return n, err
50	47	}
51	48
52	49	type ewmaProxyWriterTo struct {
53		io.ReadCloser // *ewmaProxyReader
54		wt io.WriterTo // *proxyWriterTo
55		bar *Bar
56		iT time.Time
	50	ewmaProxyReader
	51	wt proxyWriterTo
57	52	}
58	53
59		func (x *ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	54	func (x ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	55	start := time.Now()
60	56	n, err := x.wt.WriteTo(w)
61	57	if n > 0 {
62		x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
63		x.iT = time.Now()
	58	x.bar.DecoratorEwmaUpdate(time.Since(start))
64	59	}
65	60	return n, err
66	61	}
67	62
68		func newProxyReader(r io.Reader, bar *Bar) io.ReadCloser {
69		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}
	63	func (b *Bar) newProxyReader(r io.Reader) (rc io.ReadCloser) {
	64	pr := proxyReader{toReadCloser(r), b}
	65	if wt, ok := r.(io.WriterTo); ok {
	66	pw := proxyWriterTo{pr, wt}
	67	if b.hasEwmaDecorators {
	68	rc = ewmaProxyWriterTo{ewmaProxyReader{pr}, pw}
	69	} else {
	70	rc = pw
77	71	}
78		} else if isWriterTo {
79		rc = &proxyWriterTo{rc, wt, bar}
	72	} else if b.hasEwmaDecorators {
	73	rc = ewmaProxyReader{pr}
	74	} else {
	75	rc = pr
80	76	}
81	77	return rc
82	78	}

-2

proxyreader_test.go less more

66	66	p := mpb.New(mpb.WithOutput(ioutil.Discard))
67	67
68	68	var reader io.Reader = strings.NewReader(content)
69		wt := reader.(io.WriterTo)
70		tReader := &testWriterTo{reader, wt, false}
	69	tReader := &testWriterTo{reader, reader.(io.WriterTo), false}
71	70
72	71	bar := p.AddBar(int64(len(content)), mpb.BarFillerTrim())
73	72