Commit 54e688537d4db187d0f92ad3eb9209b385eb8668 - golang-github-vbauerster-mpb

+5

-0

.gitignore less more

	0	# Test binary, build with `go test -c`
	1	*.test
	2
	3	# Output of the go coverage tool, specifically when used with LiteIDE
	4	*.out

+14

-0

.travis.yml less more

	0	language: go
	1	sudo: false
	2	go:
	3	- 1.8.x
	4	- 1.9.x
	5
	6	before_install:
	7	- go get -t -v ./...
	8
	9	script:
	10	- go test -race -coverprofile=coverage.txt -covermode=atomic
	11
	12	after_success:
	13	- bash <(curl -s https://codecov.io/bash)

+29

-0

LICENSE less more

	0	BSD 3-Clause License
	1
	2	Copyright (C) 2016-2018 Vladimir Bauer
	3	All rights reserved.
	4
	5	Redistribution and use in source and binary forms, with or without
	6	modification, are permitted provided that the following conditions are met:
	7
	8	* Redistributions of source code must retain the above copyright notice, this
	9	list of conditions and the following disclaimer.
	10
	11	* Redistributions in binary form must reproduce the above copyright notice,
	12	this list of conditions and the following disclaimer in the documentation
	13	and/or other materials provided with the distribution.
	14
	15	* Neither the name of the copyright holder nor the names of its
	16	contributors may be used to endorse or promote products derived from
	17	this software without specific prior written permission.
	18
	19	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	20	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	21	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	22	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	23	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	24	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	25	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	26	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	27	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	28	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+117

-0

README.md less more

	0	# Multi Progress Bar
	1
	2	[![GoDoc](https://godoc.org/github.com/vbauerster/mpb?status.svg)](https://godoc.org/github.com/vbauerster/mpb)
	3	[![Build Status](https://travis-ci.org/vbauerster/mpb.svg?branch=master)](https://travis-ci.org/vbauerster/mpb)
	4	[![Go Report Card](https://goreportcard.com/badge/github.com/vbauerster/mpb)](https://goreportcard.com/report/github.com/vbauerster/mpb)
	5	[![codecov](https://codecov.io/gh/vbauerster/mpb/branch/master/graph/badge.svg)](https://codecov.io/gh/vbauerster/mpb)
	6
	7	mpb is a Go lib for rendering progress bars in terminal applications.
	8
	9	## Features
	10
	11	* __Multiple Bars__: Multiple progress bars are supported
	12	* __Dynamic Total__: [Set total](https://github.com/vbauerster/mpb/issues/9#issuecomment-344448984) while bar is running
	13	* __Dynamic Add/Remove__: Dynamically add or remove bars
	14	* __Cancellation__: Cancel whole rendering process
	15	* __Predefined Decorators__: Elapsed time, [ewma](https://github.com/VividCortex/ewma) based ETA, Percentage, Bytes counter
	16	* __Decorator's width sync__: Synchronized decorator's width among multiple bars
	17
	18	## Installation
	19
	20	```sh
	21	go get github.com/vbauerster/mpb
	22	```
	23
	24	_Note:_ it is preferable to go get from github.com, rather than gopkg.in. See issue [#11](https://github.com/vbauerster/mpb/issues/11).
	25
	26	## Usage
	27
	28	#### [Rendering single bar](examples/singleBar/main.go)
	29	```go
	30	p := mpb.New(
	31	// override default (80) width
	32	mpb.WithWidth(64),
	33	// override default "[=>-]" format
	34	mpb.WithFormat("╢▌▌░╟"),
	35	// override default 120ms refresh rate
	36	mpb.WithRefreshRate(180*time.Millisecond),
	37	)
	38
	39	total := 100
	40	name := "Single Bar:"
	41	// adding a single bar
	42	bar := p.AddBar(int64(total),
	43	mpb.PrependDecorators(
	44	// display our name with one space on the right
	45	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
	46	// replace ETA decorator with "done" message, OnComplete event
	47	decor.OnComplete(
	48	// ETA decorator with ewma age of 60, and width reservation of 4
	49	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
	50	),
	51	),
	52	mpb.AppendDecorators(decor.Percentage()),
	53	)
	54	// simulating some work
	55	max := 100 * time.Millisecond
	56	for i := 0; i < total; i++ {
	57	start := time.Now()
	58	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	59	// ewma based decorators require work duration measurement
	60	bar.IncrBy(1, time.Since(start))
	61	}
	62	// wait for our bar to complete and flush
	63	p.Wait()
	64	```
	65
	66	#### [Rendering multiple bars](examples/simple/main.go)
	67	```go
	68	var wg sync.WaitGroup
	69	p := mpb.New(mpb.WithWaitGroup(&wg))
	70	total, numBars := 100, 3
	71	wg.Add(numBars)
	72
	73	for i := 0; i < numBars; i++ {
	74	name := fmt.Sprintf("Bar#%d:", i)
	75	bar := p.AddBar(int64(total),
	76	mpb.PrependDecorators(
	77	// simple name decorator
	78	decor.Name(name),
	79	// decor.DSyncWidth bit enables column width synchronization
	80	decor.Percentage(decor.WCSyncSpace),
	81	),
	82	mpb.AppendDecorators(
	83	// replace ETA decorator with "done" message, OnComplete event
	84	decor.OnComplete(
	85	// ETA decorator with ewma age of 60
	86	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	87	),
	88	),
	89	)
	90	// simulating some work
	91	go func() {
	92	defer wg.Done()
	93	max := 100 * time.Millisecond
	94	for i := 0; i < total; i++ {
	95	start := time.Now()
	96	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	97	// ewma based decorators require work duration measurement
	98	bar.IncrBy(1, time.Since(start))
	99	}
	100	}()
	101	}
	102	// wait for all bars to complete and flush
	103	p.Wait()
	104	```
	105
	106	#### [Dynamic total](examples/dynTotal/main.go)
	107
	108	![dynamic total](examples/gifs/godEMrCZmJkHYH1X9dN4Nm0U7.svg)
	109
	110	#### [Complex example](examples/complex/main.go)
	111
	112	![complex](examples/gifs/wHzf1M7sd7B3zVa2scBMnjqRf.svg)
	113
	114	#### [Bytes counters](examples/io/single/main.go)
	115
	116	![byte counters](examples/gifs/hIpTa3A5rQz65ssiVuRJu87X6.svg)

+455

-0

bar.go less more

	0	package mpb
	1
	2	import (
	3	"bytes"
	4	"fmt"
	5	"io"
	6	"io/ioutil"
	7	"strings"
	8	"sync"
	9	"time"
	10	"unicode/utf8"
	11
	12	"github.com/vbauerster/mpb/decor"
	13	"github.com/vbauerster/mpb/internal"
	14	)
	15
	16	const (
	17	rLeft = iota
	18	rFill
	19	rTip
	20	rEmpty
	21	rRight
	22	)
	23
	24	const formatLen = 5
	25
	26	type barRunes [formatLen]rune
	27
	28	// Bar represents a progress Bar
	29	type Bar struct {
	30	priority int
	31	index int
	32
	33	runningBar *Bar
	34	cacheState *bState
	35	operateState chan func(*bState)
	36	int64Ch chan int64
	37	boolCh chan bool
	38	frameReaderCh chan *frameReader
	39	syncTableCh chan [][]chan int
	40
	41	// done is closed by Bar's goroutine, after cacheState is written
	42	done chan struct{}
	43	// shutdown is closed from master Progress goroutine only
	44	shutdown chan struct{}
	45	}
	46
	47	type (
	48	bState struct {
	49	id int
	50	width int
	51	total int64
	52	current int64
	53	runes barRunes
	54	trimLeftSpace bool
	55	trimRightSpace bool
	56	toComplete bool
	57	removeOnComplete bool
	58	barClearOnComplete bool
	59	completeFlushed bool
	60	aDecorators []decor.Decorator
	61	pDecorators []decor.Decorator
	62	amountReceivers []decor.AmountReceiver
	63	shutdownListeners []decor.ShutdownListener
	64	refill *refill
	65	bufP, bufB, bufA *bytes.Buffer
	66	bufNL *bytes.Buffer
	67	panicMsg string
	68	newLineExtendFn func(io.Writer, *decor.Statistics)
	69
	70	// following options are assigned to the *Bar
	71	priority int
	72	runningBar *Bar
	73	}
	74	refill struct {
	75	char rune
	76	till int64
	77	}
	78	frameReader struct {
	79	io.Reader
	80	extendedLines int
	81	toShutdown bool
	82	removeOnComplete bool
	83	}
	84	)
	85
	86	func newBar(wg sync.WaitGroup, id int, total int64, cancel <-chan struct{}, options ...BarOption) Bar {
	87	if total <= 0 {
	88	total = time.Now().Unix()
	89	}
	90
	91	s := &bState{
	92	id: id,
	93	priority: id,
	94	total: total,
	95	}
	96
	97	for _, opt := range options {
	98	if opt != nil {
	99	opt(s)
	100	}
	101	}
	102
	103	s.bufP = bytes.NewBuffer(make([]byte, 0, s.width))
	104	s.bufB = bytes.NewBuffer(make([]byte, 0, s.width))
	105	s.bufA = bytes.NewBuffer(make([]byte, 0, s.width))
	106
	107	b := &Bar{
	108	priority: s.priority,
	109	runningBar: s.runningBar,
	110	operateState: make(chan func(*bState)),
	111	int64Ch: make(chan int64),
	112	boolCh: make(chan bool),
	113	frameReaderCh: make(chan *frameReader, 1),
	114	syncTableCh: make(chan [][]chan int),
	115	done: make(chan struct{}),
	116	shutdown: make(chan struct{}),
	117	}
	118
	119	if b.runningBar != nil {
	120	b.priority = b.runningBar.priority
	121	}
	122
	123	if s.newLineExtendFn != nil {
	124	s.bufNL = bytes.NewBuffer(make([]byte, 0, s.width))
	125	}
	126
	127	go b.serve(wg, s, cancel)
	128	return b
	129	}
	130
	131	// RemoveAllPrependers removes all prepend functions.
	132	func (b *Bar) RemoveAllPrependers() {
	133	select {
	134	case b.operateState <- func(s *bState) { s.pDecorators = nil }:
	135	case <-b.done:
	136	}
	137	}
	138
	139	// RemoveAllAppenders removes all append functions.
	140	func (b *Bar) RemoveAllAppenders() {
	141	select {
	142	case b.operateState <- func(s *bState) { s.aDecorators = nil }:
	143	case <-b.done:
	144	}
	145	}
	146
	147	// ProxyReader wraps r with metrics required for progress tracking.
	148	func (b *Bar) ProxyReader(r io.Reader) io.ReadCloser {
	149	if r == nil {
	150	panic("expect io.Reader, got nil")
	151	}
	152	rc, ok := r.(io.ReadCloser)
	153	if !ok {
	154	rc = ioutil.NopCloser(r)
	155	}
	156	return &proxyReader{rc, b, time.Now()}
	157	}
	158
	159	// ID returs id of the bar.
	160	func (b *Bar) ID() int {
	161	select {
	162	case b.operateState <- func(s *bState) { b.int64Ch <- int64(s.id) }:
	163	return int(<-b.int64Ch)
	164	case <-b.done:
	165	return b.cacheState.id
	166	}
	167	}
	168
	169	// Current returns bar's current number, in other words sum of all increments.
	170	func (b *Bar) Current() int64 {
	171	select {
	172	case b.operateState <- func(s *bState) { b.int64Ch <- s.current }:
	173	return <-b.int64Ch
	174	case <-b.done:
	175	return b.cacheState.current
	176	}
	177	}
	178
	179	// SetTotal sets total dynamically.
	180	// Set final to true, when total is known, it will trigger bar complete event.
	181	func (b *Bar) SetTotal(total int64, final bool) bool {
	182	select {
	183	case b.operateState <- func(s *bState) {
	184	if total > 0 {
	185	s.total = total
	186	}
	187	if final {
	188	s.current = s.total
	189	s.toComplete = true
	190	}
	191	}:
	192	return true
	193	case <-b.done:
	194	return false
	195	}
	196	}
	197
	198	// SetRefill sets fill rune to r, up until n.
	199	func (b *Bar) SetRefill(n int, r rune) {
	200	if n <= 0 {
	201	return
	202	}
	203	b.operateState <- func(s *bState) {
	204	s.refill = &refill{r, int64(n)}
	205	}
	206	}
	207
	208	// RefillBy is deprecated, use SetRefill
	209	func (b *Bar) RefillBy(n int, r rune) {
	210	b.SetRefill(n, r)
	211	}
	212
	213	// Increment is a shorthand for b.IncrBy(1).
	214	func (b *Bar) Increment() {
	215	b.IncrBy(1)
	216	}
	217
	218	// IncrBy increments progress bar by amount of n.
	219	// wdd is optional work duration i.e. time.Since(start),
	220	// which expected to be provided, if any ewma based decorator is used.
	221	func (b *Bar) IncrBy(n int, wdd ...time.Duration) {
	222	select {
	223	case b.operateState <- func(s *bState) {
	224	s.current += int64(n)
	225	if s.current >= s.total {
	226	s.current = s.total
	227	s.toComplete = true
	228	}
	229	for _, ar := range s.amountReceivers {
	230	ar.NextAmount(n, wdd...)
	231	}
	232	}:
	233	case <-b.done:
	234	}
	235	}
	236
	237	// Completed reports whether the bar is in completed state.
	238	func (b *Bar) Completed() bool {
	239	// omit select here, because primary usage of the method is for loop
	240	// condition, like for !bar.Completed() {...}
	241	// so when toComplete=true it is called once (at which time, the bar is still alive),
	242	// then quits the loop and never suppose to be called afterwards.
	243	return <-b.boolCh
	244	}
	245
	246	func (b *Bar) wSyncTable() [][]chan int {
	247	select {
	248	case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
	249	return <-b.syncTableCh
	250	case <-b.done:
	251	return b.cacheState.wSyncTable()
	252	}
	253	}
	254
	255	func (b Bar) serve(wg sync.WaitGroup, s *bState, cancel <-chan struct{}) {
	256	defer wg.Done()
	257	for {
	258	select {
	259	case op := <-b.operateState:
	260	op(s)
	261	case b.boolCh <- s.toComplete:
	262	case <-cancel:
	263	s.toComplete = true
	264	cancel = nil
	265	case <-b.shutdown:
	266	b.cacheState = s
	267	close(b.done)
	268	for _, sl := range s.shutdownListeners {
	269	sl.Shutdown()
	270	}
	271	return
	272	}
	273	}
	274	}
	275
	276	func (b *Bar) render(debugOut io.Writer, tw int) {
	277	select {
	278	case b.operateState <- func(s *bState) {
	279	defer func() {
	280	// recovering if user defined decorator panics for example
	281	if p := recover(); p != nil {
	282	s.panicMsg = fmt.Sprintf("panic: %v", p)
	283	fmt.Fprintf(debugOut, "%s %s bar id %02d %v\n", "[mpb]", time.Now(), s.id, s.panicMsg)
	284	b.frameReaderCh <- &frameReader{
	285	Reader: strings.NewReader(fmt.Sprintf(fmt.Sprintf("%%.%ds\n", tw), s.panicMsg)),
	286	toShutdown: true,
	287	}
	288	}
	289	}()
	290	r := s.draw(tw)
	291	var extendedLines int
	292	if s.newLineExtendFn != nil {
	293	s.bufNL.Reset()
	294	s.newLineExtendFn(s.bufNL, newStatistics(s))
	295	extendedLines = countLines(s.bufNL.Bytes())
	296	r = io.MultiReader(r, s.bufNL)
	297	}
	298	b.frameReaderCh <- &frameReader{
	299	Reader: r,
	300	extendedLines: extendedLines,
	301	toShutdown: s.toComplete && !s.completeFlushed,
	302	removeOnComplete: s.removeOnComplete,
	303	}
	304	s.completeFlushed = s.toComplete
	305	}:
	306	case <-b.done:
	307	s := b.cacheState
	308	r := s.draw(tw)
	309	var extendedLines int
	310	if s.newLineExtendFn != nil {
	311	s.bufNL.Reset()
	312	s.newLineExtendFn(s.bufNL, newStatistics(s))
	313	extendedLines = countLines(s.bufNL.Bytes())
	314	r = io.MultiReader(r, s.bufNL)
	315	}
	316	b.frameReaderCh <- &frameReader{
	317	Reader: r,
	318	extendedLines: extendedLines,
	319	}
	320	}
	321	}
	322
	323	func (s *bState) draw(termWidth int) io.Reader {
	324	defer s.bufA.WriteByte('\n')
	325
	326	if s.panicMsg != "" {
	327	return strings.NewReader(fmt.Sprintf(fmt.Sprintf("%%.%ds\n", termWidth), s.panicMsg))
	328	}
	329
	330	stat := newStatistics(s)
	331
	332	for _, d := range s.pDecorators {
	333	s.bufP.WriteString(d.Decor(stat))
	334	}
	335
	336	for _, d := range s.aDecorators {
	337	s.bufA.WriteString(d.Decor(stat))
	338	}
	339
	340	prependCount := utf8.RuneCount(s.bufP.Bytes())
	341	appendCount := utf8.RuneCount(s.bufA.Bytes())
	342
	343	if s.barClearOnComplete && s.completeFlushed {
	344	return io.MultiReader(s.bufP, s.bufA)
	345	}
	346
	347	s.fillBar(s.width)
	348	barCount := utf8.RuneCount(s.bufB.Bytes())
	349	totalCount := prependCount + barCount + appendCount
	350	if spaceCount := 0; totalCount > termWidth {
	351	if !s.trimLeftSpace {
	352	spaceCount++
	353	}
	354	if !s.trimRightSpace {
	355	spaceCount++
	356	}
	357	s.fillBar(termWidth - prependCount - appendCount - spaceCount)
	358	}
	359
	360	return io.MultiReader(s.bufP, s.bufB, s.bufA)
	361	}
	362
	363	func (s *bState) fillBar(width int) {
	364	defer func() {
	365	s.bufB.WriteRune(s.runes[rRight])
	366	if !s.trimRightSpace {
	367	s.bufB.WriteByte(' ')
	368	}
	369	}()
	370
	371	s.bufB.Reset()
	372	if !s.trimLeftSpace {
	373	s.bufB.WriteByte(' ')
	374	}
	375	s.bufB.WriteRune(s.runes[rLeft])
	376	if width <= 2 {
	377	return
	378	}
	379
	380	// bar s.width without leftEnd and rightEnd runes
	381	barWidth := width - 2
	382
	383	completedWidth := internal.Percentage(s.total, s.current, int64(barWidth))
	384
	385	if s.refill != nil {
	386	till := internal.Percentage(s.total, s.refill.till, int64(barWidth))
	387	// append refill rune
	388	var i int64
	389	for i = 0; i < till; i++ {
	390	s.bufB.WriteRune(s.refill.char)
	391	}
	392	for i = till; i < completedWidth; i++ {
	393	s.bufB.WriteRune(s.runes[rFill])
	394	}
	395	} else {
	396	var i int64
	397	for i = 0; i < completedWidth; i++ {
	398	s.bufB.WriteRune(s.runes[rFill])
	399	}
	400	}
	401
	402	if completedWidth < int64(barWidth) && completedWidth > 0 {
	403	_, size := utf8.DecodeLastRune(s.bufB.Bytes())
	404	s.bufB.Truncate(s.bufB.Len() - size)
	405	s.bufB.WriteRune(s.runes[rTip])
	406	}
	407
	408	for i := completedWidth; i < int64(barWidth); i++ {
	409	s.bufB.WriteRune(s.runes[rEmpty])
	410	}
	411	}
	412
	413	func (s *bState) wSyncTable() [][]chan int {
	414	columns := make([]chan int, 0, len(s.pDecorators)+len(s.aDecorators))
	415	var pCount int
	416	for _, d := range s.pDecorators {
	417	if ok, ch := d.Syncable(); ok {
	418	columns = append(columns, ch)
	419	pCount++
	420	}
	421	}
	422	var aCount int
	423	for _, d := range s.aDecorators {
	424	if ok, ch := d.Syncable(); ok {
	425	columns = append(columns, ch)
	426	aCount++
	427	}
	428	}
	429	table := make([][]chan int, 2)
	430	table[0] = columns[0:pCount]
	431	table[1] = columns[pCount : pCount+aCount : pCount+aCount]
	432	return table
	433	}
	434
	435	func newStatistics(s bState) decor.Statistics {
	436	return &decor.Statistics{
	437	ID: s.id,
	438	Completed: s.completeFlushed,
	439	Total: s.total,
	440	Current: s.current,
	441	}
	442	}
	443
	444	func strToBarRunes(format string) (array barRunes) {
	445	for i, n := 0, 0; len(format) > 0; i++ {
	446	array[i], n = utf8.DecodeRuneInString(format)
	447	format = format[n:]
	448	}
	449	return
	450	}
	451
	452	func countLines(b []byte) int {
	453	return bytes.Count(b, []byte("\n"))
	454	}

+124

-0

bar_option.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4
	5	"github.com/vbauerster/mpb/decor"
	6	)
	7
	8	// BarOption is a function option which changes the default behavior of a bar,
	9	// if passed to p.AddBar(int64, ...BarOption)
	10	type BarOption func(*bState)
	11
	12	// AppendDecorators let you inject decorators to the bar's right side
	13	func AppendDecorators(appenders ...decor.Decorator) BarOption {
	14	return func(s *bState) {
	15	for _, decorator := range appenders {
	16	if ar, ok := decorator.(decor.AmountReceiver); ok {
	17	s.amountReceivers = append(s.amountReceivers, ar)
	18	}
	19	if sl, ok := decorator.(decor.ShutdownListener); ok {
	20	s.shutdownListeners = append(s.shutdownListeners, sl)
	21	}
	22	s.aDecorators = append(s.aDecorators, decorator)
	23	}
	24	}
	25	}
	26
	27	// PrependDecorators let you inject decorators to the bar's left side
	28	func PrependDecorators(prependers ...decor.Decorator) BarOption {
	29	return func(s *bState) {
	30	for _, decorator := range prependers {
	31	if ar, ok := decorator.(decor.AmountReceiver); ok {
	32	s.amountReceivers = append(s.amountReceivers, ar)
	33	}
	34	if sl, ok := decorator.(decor.ShutdownListener); ok {
	35	s.shutdownListeners = append(s.shutdownListeners, sl)
	36	}
	37	s.pDecorators = append(s.pDecorators, decorator)
	38	}
	39	}
	40	}
	41
	42	// BarTrimLeft trims left side space of the bar
	43	func BarTrimLeft() BarOption {
	44	return func(s *bState) {
	45	s.trimLeftSpace = true
	46	}
	47	}
	48
	49	// BarTrimRight trims right space of the bar
	50	func BarTrimRight() BarOption {
	51	return func(s *bState) {
	52	s.trimRightSpace = true
	53	}
	54	}
	55
	56	// BarTrim trims both left and right spaces of the bar
	57	func BarTrim() BarOption {
	58	return func(s *bState) {
	59	s.trimLeftSpace = true
	60	s.trimRightSpace = true
	61	}
	62	}
	63
	64	// BarID overwrites internal bar id
	65	func BarID(id int) BarOption {
	66	return func(s *bState) {
	67	s.id = id
	68	}
	69	}
	70
	71	// BarRemoveOnComplete is a flag, if set whole bar line will be removed on complete event.
	72	// If both BarRemoveOnComplete and BarClearOnComplete are set, first bar section gets cleared
	73	// and then whole bar line gets removed completely.
	74	func BarRemoveOnComplete() BarOption {
	75	return func(s *bState) {
	76	s.removeOnComplete = true
	77	}
	78	}
	79
	80	// BarReplaceOnComplete is indicator for delayed bar start, after the `runningBar` is complete.
	81	// To achieve bar replacement effect, `runningBar` should has its `BarRemoveOnComplete` option set.
	82	func BarReplaceOnComplete(runningBar *Bar) BarOption {
	83	return func(s *bState) {
	84	s.runningBar = runningBar
	85	}
	86	}
	87
	88	// BarClearOnComplete is a flag, if set will clear bar section on complete event.
	89	// If you need to remove a whole bar line, refer to BarRemoveOnComplete.
	90	func BarClearOnComplete() BarOption {
	91	return func(s *bState) {
	92	s.barClearOnComplete = true
	93	}
	94	}
	95
	96	// BarPriority sets bar's priority.
	97	// Zero is highest priority, i.e. bar will be on top.
	98	// If `BarReplaceOnComplete` option is supplied, this option is ignored.
	99	func BarPriority(priority int) BarOption {
	100	return func(s *bState) {
	101	s.priority = priority
	102	}
	103	}
	104
	105	// BarNewLineExtend takes user defined efn, which gets called each render cycle.
	106	// Any write to provided writer of efn, will appear on new line of respective bar.
	107	func BarNewLineExtend(efn func(io.Writer, *decor.Statistics)) BarOption {
	108	return func(s *bState) {
	109	s.newLineExtendFn = efn
	110	}
	111	}
	112
	113	func barWidth(w int) BarOption {
	114	return func(s *bState) {
	115	s.width = w
	116	}
	117	}
	118
	119	func barFormat(format string) BarOption {
	120	return func(s *bState) {
	121	s.runes = strToBarRunes(format)
	122	}
	123	}

+129

-0

bar_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"bytes"
	4	"fmt"
	5	"io/ioutil"
	6	"strings"
	7	"testing"
	8	"time"
	9
	10	. "github.com/vbauerster/mpb"
	11	"github.com/vbauerster/mpb/decor"
	12	)
	13
	14	func TestBarCompleted(t *testing.T) {
	15	p := New(WithOutput(ioutil.Discard))
	16	total := 80
	17	bar := p.AddBar(int64(total))
	18
	19	var count int
	20	for !bar.Completed() {
	21	time.Sleep(10 * time.Millisecond)
	22	bar.Increment()
	23	count++
	24	}
	25
	26	p.Wait()
	27	if count != total {
	28	t.Errorf("got count: %d, expected %d\n", count, total)
	29	}
	30	}
	31
	32	func TestBarID(t *testing.T) {
	33	p := New(WithOutput(ioutil.Discard))
	34	total := 80
	35	wantID := 11
	36	bar := p.AddBar(int64(total), BarID(wantID))
	37
	38	go func() {
	39	for i := 0; i < total; i++ {
	40	time.Sleep(50 * time.Millisecond)
	41	bar.Increment()
	42	}
	43	}()
	44
	45	gotID := bar.ID()
	46	if gotID != wantID {
	47	t.Errorf("Expected bar id: %d, got %d\n", wantID, gotID)
	48	}
	49
	50	p.Abort(bar, true)
	51	p.Wait()
	52	}
	53
	54	func TestBarSetRefill(t *testing.T) {
	55	var buf bytes.Buffer
	56
	57	width := 100
	58	p := New(WithOutput(&buf), WithWidth(width))
	59
	60	total := 100
	61	till := 30
	62	refillRune := '+'
	63
	64	bar := p.AddBar(int64(total), BarTrim())
	65
	66	bar.SetRefill(till, refillRune)
	67	bar.IncrBy(till)
	68
	69	for i := 0; i < total-till; i++ {
	70	bar.Increment()
	71	time.Sleep(10 * time.Millisecond)
	72	}
	73
	74	p.Wait()
	75
	76	wantBar := fmt.Sprintf("[%s%s]",
	77	strings.Repeat(string(refillRune), till-1),
	78	strings.Repeat("=", total-till-1))
	79
	80	if !strings.Contains(buf.String(), wantBar) {
	81	t.Errorf("Want bar: %s, got bar: %s\n", wantBar, buf.String())
	82	}
	83	}
	84
	85	func TestBarPanics(t *testing.T) {
	86	var buf bytes.Buffer
	87	p := New(WithDebugOutput(&buf), WithOutput(ioutil.Discard))
	88
	89	wantPanic := "Upps!!!"
	90	total := 100
	91
	92	bar := p.AddBar(int64(total), PrependDecorators(panicDecorator(wantPanic)))
	93
	94	go func() {
	95	for i := 0; i < 100; i++ {
	96	time.Sleep(10 * time.Millisecond)
	97	bar.Increment()
	98	}
	99	}()
	100
	101	p.Wait()
	102
	103	wantPanic = fmt.Sprintf("panic: %s", wantPanic)
	104	debugStr := buf.String()
	105	if !strings.Contains(debugStr, wantPanic) {
	106	t.Errorf("%q doesn't contain %q\n", debugStr, wantPanic)
	107	}
	108	}
	109
	110	func panicDecorator(panicMsg string) decor.Decorator {
	111	d := &decorator{
	112	panicMsg: panicMsg,
	113	}
	114	d.Init()
	115	return d
	116	}
	117
	118	type decorator struct {
	119	decor.WC
	120	panicMsg string
	121	}
	122
	123	func (d decorator) Decor(st decor.Statistics) string {
	124	if st.Current >= 42 {
	125	panic(d.panicMsg)
	126	}
	127	return d.FormatMsg("")
	128	}

+43

-0

barbench_test.go less more

	0	package mpb
	1
	2	import (
	3	"io/ioutil"
	4	"testing"
	5
	6	"github.com/vbauerster/mpb/decor"
	7	)
	8
	9	func BenchmarkIncrSingleBar(b *testing.B) {
	10	p := New(WithOutput(ioutil.Discard))
	11	bar := p.AddBar(int64(b.N))
	12	for i := 0; i < b.N; i++ {
	13	bar.Increment()
	14	}
	15	}
	16
	17	func BenchmarkIncrSingleBarWhileIsNotCompleted(b *testing.B) {
	18	p := New(WithOutput(ioutil.Discard))
	19	bar := p.AddBar(int64(b.N))
	20	for !bar.Completed() {
	21	bar.Increment()
	22	}
	23	}
	24
	25	func BenchmarkIncrSingleBarWithNameDecorator(b *testing.B) {
	26	p := New(WithOutput(ioutil.Discard))
	27	bar := p.AddBar(int64(b.N), PrependDecorators(decor.Name("test")))
	28	for i := 0; i < b.N; i++ {
	29	bar.Increment()
	30	}
	31	}
	32
	33	func BenchmarkIncrSingleBarWithNameAndEwmaETADecorator(b *testing.B) {
	34	p := New(WithOutput(ioutil.Discard))
	35	bar := p.AddBar(int64(b.N),
	36	PrependDecorators(decor.Name("test")),
	37	AppendDecorators(decor.EwmaETA(decor.ET_STYLE_GO, 60)),
	38	)
	39	for i := 0; i < b.N; i++ {
	40	bar.Increment()
	41	}
	42	}

+3

-0

cwriter/export_test.go less more

	0	package cwriter
	1
	2	var ClearCursorAndLine = clearCursorAndLine

+78

-0

cwriter/writer.go less more

	0	package cwriter
	1
	2	import (
	3	"bytes"
	4	"errors"
	5	"fmt"
	6	"io"
	7	"os"
	8
	9	isatty "github.com/mattn/go-isatty"
	10	"golang.org/x/crypto/ssh/terminal"
	11	)
	12
	13	// ESC is the ASCII code for escape character
	14	const ESC = 27
	15
	16	var NotATTY = errors.New("not a terminal")
	17
	18	var (
	19	cursorUp = fmt.Sprintf("%c[%dA", ESC, 1)
	20	clearLine = fmt.Sprintf("%c[2K\r", ESC)
	21	clearCursorAndLine = cursorUp + clearLine
	22	)
	23
	24	// Writer is a buffered the writer that updates the terminal.
	25	// The contents of writer will be flushed when Flush is called.
	26	type Writer struct {
	27	out io.Writer
	28	buf bytes.Buffer
	29	isTerminal bool
	30	fd int
	31	lineCount int
	32	}
	33
	34	// New returns a new Writer with defaults
	35	func New(out io.Writer) *Writer {
	36	w := &Writer{out: out}
	37	if f, ok := out.(*os.File); ok {
	38	fd := f.Fd()
	39	w.isTerminal = isatty.IsTerminal(fd)
	40	w.fd = int(fd)
	41	}
	42	return w
	43	}
	44
	45	// Flush flushes the underlying buffer
	46	func (w *Writer) Flush(lineCount int) error {
	47	err := w.clearLines()
	48	w.lineCount = lineCount
	49	// WriteTo takes care of w.buf.Reset
	50	if _, e := w.buf.WriteTo(w.out); err == nil {
	51	err = e
	52	}
	53	return err
	54	}
	55
	56	// Write appends the contents of p to the underlying buffer
	57	func (w *Writer) Write(p []byte) (n int, err error) {
	58	return w.buf.Write(p)
	59	}
	60
	61	// WriteString writes string to the underlying buffer
	62	func (w *Writer) WriteString(s string) (n int, err error) {
	63	return w.buf.WriteString(s)
	64	}
	65
	66	// ReadFrom reads from the provided io.Reader and writes to the underlying buffer.
	67	func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
	68	return w.buf.ReadFrom(r)
	69	}
	70
	71	func (w *Writer) GetWidth() (int, error) {
	72	if w.isTerminal {
	73	tw, _, err := terminal.GetSize(w.fd)
	74	return tw, err
	75	}
	76	return -1, NotATTY
	77	}

+13

-0

cwriter/writer_posix.go less more

	0	// +build !windows
	1
	2	package cwriter
	3
	4	import (
	5	"io"
	6	"strings"
	7	)
	8
	9	func (w *Writer) clearLines() error {
	10	_, err := io.WriteString(w.out, strings.Repeat(clearCursorAndLine, w.lineCount))
	11	return err
	12	}

+36

-0

cwriter/writer_posix_test.go less more

	0	// +build !windows
	1
	2	package cwriter_test
	3
	4	import (
	5	"bytes"
	6	"testing"
	7
	8	. "github.com/vbauerster/mpb/cwriter"
	9	)
	10
	11	// TestWriterPosix by writing and flushing many times. The output buffer
	12	// must contain the clearCursor and clearLine sequences.
	13	func TestWriterPosix(t *testing.T) {
	14	out := new(bytes.Buffer)
	15	w := New(out)
	16
	17	for _, tcase := range []struct {
	18	input, expectedOutput string
	19	}{
	20	{input: "foo\n", expectedOutput: "foo\n"},
	21	{input: "bar\n", expectedOutput: "foo\n" + ClearCursorAndLine + "bar\n"},
	22	{input: "fizz\n", expectedOutput: "foo\n" + ClearCursorAndLine + "bar\n" + ClearCursorAndLine + "fizz\n"},
	23	} {
	24	t.Run(tcase.input, func(t *testing.T) {
	25	s := []byte(tcase.input)
	26	lc := bytes.Count(s, []byte("\n"))
	27	w.Write(s)
	28	w.Flush(lc)
	29	output := out.String()
	30	if output != tcase.expectedOutput {
	31	t.Fatalf("want %q, got %q", tcase.expectedOutput, output)
	32	}
	33	})
	34	}
	35	}

+77

-0

cwriter/writer_windows.go less more

	0	// +build windows
	1
	2	package cwriter
	3
	4	import (
	5	"io"
	6	"strings"
	7	"syscall"
	8	"unsafe"
	9
	10	"github.com/mattn/go-isatty"
	11	)
	12
	13	var kernel32 = syscall.NewLazyDLL("kernel32.dll")
	14
	15	var (
	16	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
	17	procSetConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition")
	18	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
	19	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
	20	)
	21
	22	type (
	23	short int16
	24	word uint16
	25	dword uint32
	26
	27	coord struct {
	28	x short
	29	y short
	30	}
	31	smallRect struct {
	32	left short
	33	top short
	34	right short
	35	bottom short
	36	}
	37	consoleScreenBufferInfo struct {
	38	size coord
	39	cursorPosition coord
	40	attributes word
	41	window smallRect
	42	maximumWindowSize coord
	43	}
	44	)
	45
	46	// FdWriter is a writer with a file descriptor.
	47	type FdWriter interface {
	48	io.Writer
	49	Fd() uintptr
	50	}
	51
	52	func (w *Writer) clearLines() error {
	53	f, ok := w.out.(FdWriter)
	54	if ok && !isatty.IsTerminal(f.Fd()) {
	55	_, err := io.WriteString(w.out, strings.Repeat(clearCursorAndLine, w.lineCount))
	56	return err
	57	}
	58	fd := f.Fd()
	59	var info consoleScreenBufferInfo
	60	procGetConsoleScreenBufferInfo.Call(fd, uintptr(unsafe.Pointer(&info)))
	61
	62	for i := 0; i < w.lineCount; i++ {
	63	// move the cursor up
	64	info.cursorPosition.y--
	65	procSetConsoleCursorPosition.Call(fd, uintptr((int32)(unsafe.Pointer(&info.cursorPosition))))
	66	// clear the line
	67	cursor := coord{
	68	x: info.window.left,
	69	y: info.window.top + info.cursorPosition.y,
	70	}
	71	var count, w dword
	72	count = dword(info.size.x)
	73	procFillConsoleOutputCharacter.Call(fd, uintptr(' '), uintptr(count), (uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&w)))
	74	}
	75	return nil
	76	}

+206

-0

decor/counters.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"strconv"
	6	"strings"
	7	)
	8
	9	const (
	10	_ = iota
	11	KiB = 1 << (iota * 10)
	12	MiB
	13	GiB
	14	TiB
	15	)
	16
	17	const (
	18	KB = 1000
	19	MB = KB * 1000
	20	GB = MB * 1000
	21	TB = GB * 1000
	22	)
	23
	24	const (
	25	_ = iota
	26	UnitKiB
	27	UnitKB
	28	)
	29
	30	type CounterKiB int64
	31
	32	func (c CounterKiB) Format(st fmt.State, verb rune) {
	33	prec, ok := st.Precision()
	34
	35	if verb == 'd' \|\| !ok {
	36	prec = 0
	37	}
	38	if verb == 'f' && !ok {
	39	prec = 6
	40	}
	41	// retain old beahavior if s verb used
	42	if verb == 's' {
	43	prec = 1
	44	}
	45
	46	var res, unit string
	47	switch {
	48	case c >= TiB:
	49	unit = "TiB"
	50	res = strconv.FormatFloat(float64(c)/TiB, 'f', prec, 64)
	51	case c >= GiB:
	52	unit = "GiB"
	53	res = strconv.FormatFloat(float64(c)/GiB, 'f', prec, 64)
	54	case c >= MiB:
	55	unit = "MiB"
	56	res = strconv.FormatFloat(float64(c)/MiB, 'f', prec, 64)
	57	case c >= KiB:
	58	unit = "KiB"
	59	res = strconv.FormatFloat(float64(c)/KiB, 'f', prec, 64)
	60	default:
	61	unit = "b"
	62	res = strconv.FormatInt(int64(c), 10)
	63	}
	64
	65	if st.Flag(' ') {
	66	res += " "
	67	}
	68	res += unit
	69
	70	if w, ok := st.Width(); ok {
	71	if len(res) < w {
	72	pad := strings.Repeat(" ", w-len(res))
	73	if st.Flag(int('-')) {
	74	res += pad
	75	} else {
	76	res = pad + res
	77	}
	78	}
	79	}
	80
	81	io.WriteString(st, res)
	82	}
	83
	84	type CounterKB int64
	85
	86	func (c CounterKB) Format(st fmt.State, verb rune) {
	87	prec, ok := st.Precision()
	88
	89	if verb == 'd' \|\| !ok {
	90	prec = 0
	91	}
	92	if verb == 'f' && !ok {
	93	prec = 6
	94	}
	95	// retain old beahavior if s verb used
	96	if verb == 's' {
	97	prec = 1
	98	}
	99
	100	var res, unit string
	101	switch {
	102	case c >= TB:
	103	unit = "TB"
	104	res = strconv.FormatFloat(float64(c)/TB, 'f', prec, 64)
	105	case c >= GB:
	106	unit = "GB"
	107	res = strconv.FormatFloat(float64(c)/GB, 'f', prec, 64)
	108	case c >= MB:
	109	unit = "MB"
	110	res = strconv.FormatFloat(float64(c)/MB, 'f', prec, 64)
	111	case c >= KB:
	112	unit = "kB"
	113	res = strconv.FormatFloat(float64(c)/KB, 'f', prec, 64)
	114	default:
	115	unit = "b"
	116	res = strconv.FormatInt(int64(c), 10)
	117	}
	118
	119	if st.Flag(' ') {
	120	res += " "
	121	}
	122	res += unit
	123
	124	if w, ok := st.Width(); ok {
	125	if len(res) < w {
	126	pad := strings.Repeat(" ", w-len(res))
	127	if st.Flag(int('-')) {
	128	res += pad
	129	} else {
	130	res = pad + res
	131	}
	132	}
	133	}
	134
	135	io.WriteString(st, res)
	136	}
	137
	138	// CountersNoUnit is a wrapper around Counters with no unit param.
	139	func CountersNoUnit(pairFormat string, wcc ...WC) Decorator {
	140	return Counters(0, pairFormat, wcc...)
	141	}
	142
	143	// CountersKibiByte is a wrapper around Counters with predefined unit UnitKiB (bytes/1024).
	144	func CountersKibiByte(pairFormat string, wcc ...WC) Decorator {
	145	return Counters(UnitKiB, pairFormat, wcc...)
	146	}
	147
	148	// CountersKiloByte is a wrapper around Counters with predefined unit UnitKB (bytes/1000).
	149	func CountersKiloByte(pairFormat string, wcc ...WC) Decorator {
	150	return Counters(UnitKB, pairFormat, wcc...)
	151	}
	152
	153	// Counters decorator with dynamic unit measure adjustment.
	154	//
	155	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	156	//
	157	// `pairFormat` printf compatible verbs for current and total, like "%f" or "%d"
	158	//
	159	// `wcc` optional WC config
	160	//
	161	// pairFormat example if UnitKB is chosen:
	162	//
	163	// "%.1f / %.1f" = "1.0MB / 12.0MB" or "% .1f / % .1f" = "1.0 MB / 12.0 MB"
	164	func Counters(unit int, pairFormat string, wcc ...WC) Decorator {
	165	var wc WC
	166	for _, widthConf := range wcc {
	167	wc = widthConf
	168	}
	169	wc.Init()
	170	d := &countersDecorator{
	171	WC: wc,
	172	unit: unit,
	173	pairFormat: pairFormat,
	174	}
	175	return d
	176	}
	177
	178	type countersDecorator struct {
	179	WC
	180	unit int
	181	pairFormat string
	182	completeMsg *string
	183	}
	184
	185	func (d countersDecorator) Decor(st Statistics) string {
	186	if st.Completed && d.completeMsg != nil {
	187	return d.FormatMsg(*d.completeMsg)
	188	}
	189
	190	var str string
	191	switch d.unit {
	192	case UnitKiB:
	193	str = fmt.Sprintf(d.pairFormat, CounterKiB(st.Current), CounterKiB(st.Total))
	194	case UnitKB:
	195	str = fmt.Sprintf(d.pairFormat, CounterKB(st.Current), CounterKB(st.Total))
	196	default:
	197	str = fmt.Sprintf(d.pairFormat, st.Current, st.Total)
	198	}
	199
	200	return d.FormatMsg(str)
	201	}
	202
	203	func (d *countersDecorator) OnCompleteMessage(msg string) {
	204	d.completeMsg = &msg
	205	}

+142

-0

decor/counters_test.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"testing"
	5	)
	6
	7	func TestCounterKiB(t *testing.T) {
	8	cases := map[string]struct {
	9	value int64
	10	verb string
	11	expected string
	12	}{
	13	"verb %f": {12345678, "%f", "11.773756MiB"},
	14	"verb %.0f": {12345678, "%.0f", "12MiB"},
	15	"verb %.1f": {12345678, "%.1f", "11.8MiB"},
	16	"verb %.2f": {12345678, "%.2f", "11.77MiB"},
	17	"verb %.3f": {12345678, "%.3f", "11.774MiB"},
	18
	19	"verb % f": {12345678, "% f", "11.773756 MiB"},
	20	"verb % .0f": {12345678, "% .0f", "12 MiB"},
	21	"verb % .1f": {12345678, "% .1f", "11.8 MiB"},
	22	"verb % .2f": {12345678, "% .2f", "11.77 MiB"},
	23	"verb % .3f": {12345678, "% .3f", "11.774 MiB"},
	24
	25	"verb %8.f": {12345678, "%8.f", " 12MiB"},
	26	"verb %8.0f": {12345678, "%8.0f", " 12MiB"},
	27	"verb %8.1f": {12345678, "%8.1f", " 11.8MiB"},
	28	"verb %8.2f": {12345678, "%8.2f", "11.77MiB"},
	29	"verb %8.3f": {12345678, "%8.3f", "11.774MiB"},
	30
	31	"verb % 8.f": {12345678, "% 8.f", " 12 MiB"},
	32	"verb % 8.0f": {12345678, "% 8.0f", " 12 MiB"},
	33	"verb % 8.1f": {12345678, "% 8.1f", "11.8 MiB"},
	34
	35	"verb %-8.f": {12345678, "%-8.f", "12MiB "},
	36	"verb %-8.0f": {12345678, "%-8.0f", "12MiB "},
	37	"verb %-8.1f": {12345678, "%-8.1f", "11.8MiB "},
	38	"verb %-8.2f": {12345678, "%8.2f", "11.77MiB"},
	39	"verb %-8.3f": {12345678, "%8.3f", "11.774MiB"},
	40
	41	"verb % -8.f": {12345678, "% -8.f", "12 MiB "},
	42	"verb % -8.0f": {12345678, "% -8.0f", "12 MiB "},
	43	"verb % -8.1f": {12345678, "% -8.1f", "11.8 MiB"},
	44
	45	"1000 %f": {1000, "%f", "1000b"},
	46	"1000 %d": {1000, "%d", "1000b"},
	47	"1000 %s": {1000, "%s", "1000b"},
	48	"1024 %f": {1024, "%f", "1.000000KiB"},
	49	"1024 %d": {1024, "%d", "1KiB"},
	50	"1024 %.1f": {1024, "%.1f", "1.0KiB"},
	51	"1024 %s": {1024, "%s", "1.0KiB"},
	52	"3MiB+140KiB %f": {3MiB + 140*KiB, "%f", "3.136719MiB"},
	53	"3MiB+140KiB %d": {3MiB + 140*KiB, "%d", "3MiB"},
	54	"3MiB+140KiB %.1f": {3MiB + 140*KiB, "%.1f", "3.1MiB"},
	55	"3MiB+140KiB %s": {3MiB + 140*KiB, "%s", "3.1MiB"},
	56	"2GiB %f": {2 GiB, "%f", "2.000000GiB"},
	57	"2GiB %d": {2 GiB, "%d", "2GiB"},
	58	"2GiB %.1f": {2 GiB, "%.1f", "2.0GiB"},
	59	"2GiB %s": {2 GiB, "%s", "2.0GiB"},
	60	"4TiB %f": {4 TiB, "%f", "4.000000TiB"},
	61	"4TiB %d": {4 TiB, "%d", "4TiB"},
	62	"4TiB %.1f": {4 TiB, "%.1f", "4.0TiB"},
	63	"4TiB %s": {4 TiB, "%s", "4.0TiB"},
	64	}
	65	for name, tc := range cases {
	66	t.Run(name, func(t *testing.T) {
	67	got := fmt.Sprintf(tc.verb, CounterKiB(tc.value))
	68	if got != tc.expected {
	69	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	70	}
	71	})
	72	}
	73	}
	74
	75	func TestCounterKB(t *testing.T) {
	76	cases := map[string]struct {
	77	value int64
	78	verb string
	79	expected string
	80	}{
	81	"verb %f": {12345678, "%f", "12.345678MB"},
	82	"verb %.0f": {12345678, "%.0f", "12MB"},
	83	"verb %.1f": {12345678, "%.1f", "12.3MB"},
	84	"verb %.2f": {12345678, "%.2f", "12.35MB"},
	85	"verb %.3f": {12345678, "%.3f", "12.346MB"},
	86
	87	"verb % f": {12345678, "% f", "12.345678 MB"},
	88	"verb % .0f": {12345678, "% .0f", "12 MB"},
	89	"verb % .1f": {12345678, "% .1f", "12.3 MB"},
	90	"verb % .2f": {12345678, "% .2f", "12.35 MB"},
	91	"verb % .3f": {12345678, "% .3f", "12.346 MB"},
	92
	93	"verb %8.f": {12345678, "%8.f", " 12MB"},
	94	"verb %8.0f": {12345678, "%8.0f", " 12MB"},
	95	"verb %8.1f": {12345678, "%8.1f", " 12.3MB"},
	96	"verb %8.2f": {12345678, "%8.2f", " 12.35MB"},
	97	"verb %8.3f": {12345678, "%8.3f", "12.346MB"},
	98
	99	"verb % 8.f": {12345678, "% 8.f", " 12 MB"},
	100	"verb % 8.0f": {12345678, "% 8.0f", " 12 MB"},
	101	"verb % 8.1f": {12345678, "% 8.1f", " 12.3 MB"},
	102
	103	"verb %-8.f": {12345678, "%-8.f", "12MB "},
	104	"verb %-8.0f": {12345678, "%-8.0f", "12MB "},
	105	"verb %-8.1f": {12345678, "%-8.1f", "12.3MB "},
	106	"verb %-8.2f": {12345678, "%8.2f", " 12.35MB"},
	107	"verb %-8.3f": {12345678, "%8.3f", "12.346MB"},
	108
	109	"verb % -8.f": {12345678, "% -8.f", "12 MB "},
	110	"verb % -8.0f": {12345678, "% -8.0f", "12 MB "},
	111	"verb % -8.1f": {12345678, "% -8.1f", "12.3 MB "},
	112
	113	"1000 %f": {1000, "%f", "1.000000kB"},
	114	"1000 %d": {1000, "%d", "1kB"},
	115	"1000 %s": {1000, "%s", "1.0kB"},
	116	"1024 %f": {1024, "%f", "1.024000kB"},
	117	"1024 %d": {1024, "%d", "1kB"},
	118	"1024 %.1f": {1024, "%.1f", "1.0kB"},
	119	"1024 %s": {1024, "%s", "1.0kB"},
	120	"3MB+140KB %f": {3MB + 140KB, "%f", "3.140000MB"},
	121	"3MB+140KB %d": {3MB + 140KB, "%d", "3MB"},
	122	"3MB+140KB %.1f": {3MB + 140KB, "%.1f", "3.1MB"},
	123	"3MB+140KB %s": {3MB + 140KB, "%s", "3.1MB"},
	124	"2GB %f": {2 GB, "%f", "2.000000GB"},
	125	"2GB %d": {2 GB, "%d", "2GB"},
	126	"2GB %.1f": {2 GB, "%.1f", "2.0GB"},
	127	"2GB %s": {2 GB, "%s", "2.0GB"},
	128	"4TB %f": {4 TB, "%f", "4.000000TB"},
	129	"4TB %d": {4 TB, "%d", "4TB"},
	130	"4TB %.1f": {4 TB, "%.1f", "4.0TB"},
	131	"4TB %s": {4 TB, "%s", "4.0TB"},
	132	}
	133	for name, tc := range cases {
	134	t.Run(name, func(t *testing.T) {
	135	got := fmt.Sprintf(tc.verb, CounterKB(tc.value))
	136	if got != tc.expected {
	137	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	138	}
	139	})
	140	}
	141	}

+144

-0

decor/decorator.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"time"
	5	"unicode/utf8"
	6	)
	7
	8	const (
	9	// DidentRight bit specifies identation direction.
	10	// \|foo \|b \| With DidentRight
	11	// \| foo\| b\| Without DidentRight
	12	DidentRight = 1 << iota
	13
	14	// DextraSpace bit adds extra space, makes sense with DSyncWidth only.
	15	// When DidentRight bit set, the space will be added to the right,
	16	// otherwise to the left.
	17	DextraSpace
	18
	19	// DSyncWidth bit enables same column width synchronization.
	20	// Effective with multiple bars only.
	21	DSyncWidth
	22
	23	// DSyncWidthR is shortcut for DSyncWidth\|DidentRight
	24	DSyncWidthR = DSyncWidth \| DidentRight
	25
	26	// DSyncSpace is shortcut for DSyncWidth\|DextraSpace
	27	DSyncSpace = DSyncWidth \| DextraSpace
	28
	29	// DSyncSpaceR is shortcut for DSyncWidth\|DextraSpace\|DidentRight
	30	DSyncSpaceR = DSyncWidth \| DextraSpace \| DidentRight
	31	)
	32
	33	const (
	34	ET_STYLE_GO = iota
	35	ET_STYLE_HHMMSS
	36	ET_STYLE_HHMM
	37	ET_STYLE_MMSS
	38	)
	39
	40	// Statistics is a struct, which gets passed to a Decorator.
	41	type Statistics struct {
	42	ID int
	43	Completed bool
	44	Total int64
	45	Current int64
	46	}
	47
	48	// Decorator interface.
	49	// A decorator must implement this interface, in order to be used with mpb library.
	50	type Decorator interface {
	51	Decor(*Statistics) string
	52	Syncable
	53	}
	54
	55	// Syncable interface.
	56	// All decorators implement this interface implicitly.
	57	// Its Syncable method exposes width sync channel, if sync is enabled.
	58	type Syncable interface {
	59	Syncable() (bool, chan int)
	60	}
	61
	62	// OnCompleteMessenger interface.
	63	// Decorators implementing this interface suppose to return provided string on complete event.
	64	type OnCompleteMessenger interface {
	65	OnCompleteMessage(string)
	66	}
	67
	68	// AmountReceiver interface.
	69	// If decorator needs to receive increment amount,
	70	// so this is the right interface to implement.
	71	type AmountReceiver interface {
	72	NextAmount(int, ...time.Duration)
	73	}
	74
	75	// ShutdownListener interface.
	76	// If decorator needs to be notified once upon bar shutdown event,
	77	// so this is the right interface to implement.
	78	type ShutdownListener interface {
	79	Shutdown()
	80	}
	81
	82	// Global convenience shortcuts
	83	var (
	84	WCSyncWidth = WC{C: DSyncWidth}
	85	WCSyncWidthR = WC{C: DSyncWidthR}
	86	WCSyncSpace = WC{C: DSyncSpace}
	87	WCSyncSpaceR = WC{C: DSyncSpaceR}
	88	)
	89
	90	// WC is a struct with two public fields W and C, both of int type.
	91	// W represents width and C represents bit set of width related config.
	92	type WC struct {
	93	W int
	94	C int
	95	format string
	96	wsync chan int
	97	}
	98
	99	// FormatMsg formats final message according to WC.W and WC.C.
	100	// Should be called by any Decorator implementation.
	101	func (wc WC) FormatMsg(msg string) string {
	102	if (wc.C & DSyncWidth) != 0 {
	103	wc.wsync <- utf8.RuneCountInString(msg)
	104	max := <-wc.wsync
	105	if max == 0 {
	106	max = wc.W
	107	}
	108	if (wc.C & DextraSpace) != 0 {
	109	max++
	110	}
	111	return fmt.Sprintf(fmt.Sprintf(wc.format, max), msg)
	112	}
	113	return fmt.Sprintf(fmt.Sprintf(wc.format, wc.W), msg)
	114	}
	115
	116	// Init initializes width related config.
	117	func (wc *WC) Init() {
	118	wc.format = "%%"
	119	if (wc.C & DidentRight) != 0 {
	120	wc.format += "-"
	121	}
	122	wc.format += "%ds"
	123	if (wc.C & DSyncWidth) != 0 {
	124	wc.wsync = make(chan int)
	125	}
	126	}
	127
	128	func (wc *WC) Syncable() (bool, chan int) {
	129	return (wc.C & DSyncWidth) != 0, wc.wsync
	130	}
	131
	132	// OnComplete returns decorator, which wraps provided decorator, with sole
	133	// purpose to display provided message on complete event.
	134	//
	135	// `decorator` Decorator to wrap
	136	//
	137	// `message` message to display on complete event
	138	func OnComplete(decorator Decorator, message string) Decorator {
	139	if d, ok := decorator.(OnCompleteMessenger); ok {
	140	d.OnCompleteMessage(message)
	141	}
	142	return decorator
	143	}

+25

-0

decor/doc.go less more

	0	// Copyright (C) 2016-2018 Vladimir Bauer
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	/*
	5	Package decor contains common decorators used by "github.com/vbauerster/mpb" package.
	6
	7	Some decorators returned by this package might have a closure state. It is ok to use
	8	decorators concurrently, unless you share the same decorator among multiple
	9	mpb.Bar instances. To avoid data races, create new decorator per mpb.Bar instance.
	10
	11	Don't:
	12
	13	p := mpb.New()
	14	name := decor.Name("bar")
	15	p.AddBar(100, mpb.AppendDecorators(name))
	16	p.AddBar(100, mpb.AppendDecorators(name))
	17
	18	Do:
	19
	20	p := mpb.New()
	21	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar1")))
	22	p.AddBar(100, mpb.AppendDecorators(decor.Name("bar2")))
	23	*/
	24	package decor

+68

-0

decor/elapsed.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"time"
	5	)
	6
	7	// Elapsed returns elapsed time decorator.
	8	//
	9	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	10	//
	11	// `wcc` optional WC config
	12	func Elapsed(style int, wcc ...WC) Decorator {
	13	var wc WC
	14	for _, widthConf := range wcc {
	15	wc = widthConf
	16	}
	17	wc.Init()
	18	d := &elapsedDecorator{
	19	WC: wc,
	20	style: style,
	21	startTime: time.Now(),
	22	}
	23	return d
	24	}
	25
	26	type elapsedDecorator struct {
	27	WC
	28	style int
	29	startTime time.Time
	30	msg string
	31	completeMsg *string
	32	}
	33
	34	func (d elapsedDecorator) Decor(st Statistics) string {
	35	if st.Completed {
	36	if d.completeMsg != nil {
	37	return d.FormatMsg(*d.completeMsg)
	38	}
	39	return d.FormatMsg(d.msg)
	40	}
	41
	42	timeElapsed := time.Since(d.startTime)
	43	hours := int64((timeElapsed / time.Hour) % 60)
	44	minutes := int64((timeElapsed / time.Minute) % 60)
	45	seconds := int64((timeElapsed / time.Second) % 60)
	46
	47	switch d.style {
	48	case ET_STYLE_GO:
	49	d.msg = fmt.Sprint(time.Duration(timeElapsed.Seconds()) * time.Second)
	50	case ET_STYLE_HHMMSS:
	51	d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	52	case ET_STYLE_HHMM:
	53	d.msg = fmt.Sprintf("%02d:%02d", hours, minutes)
	54	case ET_STYLE_MMSS:
	55	if hours > 0 {
	56	d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	57	} else {
	58	d.msg = fmt.Sprintf("%02d:%02d", minutes, seconds)
	59	}
	60	}
	61
	62	return d.FormatMsg(d.msg)
	63	}
	64
	65	func (d *elapsedDecorator) OnCompleteMessage(msg string) {
	66	d.completeMsg = &msg
	67	}

+207

-0

decor/eta.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"math"
	5	"time"
	6
	7	"github.com/VividCortex/ewma"
	8	"github.com/vbauerster/mpb/internal"
	9	)
	10
	11	type TimeNormalizer func(time.Duration) time.Duration
	12
	13	// EwmaETA exponential-weighted-moving-average based ETA decorator.
	14	//
	15	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	16	//
	17	// `age` is the previous N samples to average over.
	18	//
	19	// `wcc` optional WC config
	20	func EwmaETA(style int, age float64, wcc ...WC) Decorator {
	21	return MovingAverageETA(style, ewma.NewMovingAverage(age), NopNormalizer(), wcc...)
	22	}
	23
	24	// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average.
	25	//
	26	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	27	//
	28	// `average` available implementations of MovingAverage [ewma.MovingAverage\|NewMedian\|NewMedianEwma]
	29	//
	30	// `normalizer` available implementations are [NopNormalizer\|FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
	31	//
	32	// `wcc` optional WC config
	33	func MovingAverageETA(style int, average MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
	34	var wc WC
	35	for _, widthConf := range wcc {
	36	wc = widthConf
	37	}
	38	wc.Init()
	39	d := &movingAverageETA{
	40	WC: wc,
	41	style: style,
	42	average: average,
	43	normalizer: normalizer,
	44	}
	45	return d
	46	}
	47
	48	type movingAverageETA struct {
	49	WC
	50	style int
	51	average ewma.MovingAverage
	52	completeMsg *string
	53	normalizer TimeNormalizer
	54	}
	55
	56	func (d movingAverageETA) Decor(st Statistics) string {
	57	if st.Completed && d.completeMsg != nil {
	58	return d.FormatMsg(*d.completeMsg)
	59	}
	60
	61	v := internal.Round(d.average.Value())
	62	remaining := d.normalizer(time.Duration((st.Total - st.Current) * int64(v)))
	63	hours := int64((remaining / time.Hour) % 60)
	64	minutes := int64((remaining / time.Minute) % 60)
	65	seconds := int64((remaining / time.Second) % 60)
	66
	67	var str string
	68	switch d.style {
	69	case ET_STYLE_GO:
	70	str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
	71	case ET_STYLE_HHMMSS:
	72	str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	73	case ET_STYLE_HHMM:
	74	str = fmt.Sprintf("%02d:%02d", hours, minutes)
	75	case ET_STYLE_MMSS:
	76	if hours > 0 {
	77	str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	78	} else {
	79	str = fmt.Sprintf("%02d:%02d", minutes, seconds)
	80	}
	81	}
	82
	83	return d.FormatMsg(str)
	84	}
	85
	86	func (d *movingAverageETA) NextAmount(n int, wdd ...time.Duration) {
	87	var workDuration time.Duration
	88	for _, wd := range wdd {
	89	workDuration = wd
	90	}
	91	lastItemEstimate := float64(workDuration) / float64(n)
	92	if math.IsInf(lastItemEstimate, 0) \|\| math.IsNaN(lastItemEstimate) {
	93	return
	94	}
	95	d.average.Add(lastItemEstimate)
	96	}
	97
	98	func (d *movingAverageETA) OnCompleteMessage(msg string) {
	99	d.completeMsg = &msg
	100	}
	101
	102	// AverageETA decorator.
	103	//
	104	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	105	//
	106	// `wcc` optional WC config
	107	func AverageETA(style int, wcc ...WC) Decorator {
	108	var wc WC
	109	for _, widthConf := range wcc {
	110	wc = widthConf
	111	}
	112	wc.Init()
	113	d := &averageETA{
	114	WC: wc,
	115	style: style,
	116	startTime: time.Now(),
	117	}
	118	return d
	119	}
	120
	121	type averageETA struct {
	122	WC
	123	style int
	124	startTime time.Time
	125	completeMsg *string
	126	}
	127
	128	func (d averageETA) Decor(st Statistics) string {
	129	if st.Completed && d.completeMsg != nil {
	130	return d.FormatMsg(*d.completeMsg)
	131	}
	132
	133	var str string
	134	timeElapsed := time.Since(d.startTime)
	135	v := internal.Round(float64(timeElapsed) / float64(st.Current))
	136	if math.IsInf(v, 0) \|\| math.IsNaN(v) {
	137	v = 0
	138	}
	139	remaining := time.Duration((st.Total - st.Current) * int64(v))
	140	hours := int64((remaining / time.Hour) % 60)
	141	minutes := int64((remaining / time.Minute) % 60)
	142	seconds := int64((remaining / time.Second) % 60)
	143
	144	switch d.style {
	145	case ET_STYLE_GO:
	146	str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
	147	case ET_STYLE_HHMMSS:
	148	str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	149	case ET_STYLE_HHMM:
	150	str = fmt.Sprintf("%02d:%02d", hours, minutes)
	151	case ET_STYLE_MMSS:
	152	if hours > 0 {
	153	str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	154	} else {
	155	str = fmt.Sprintf("%02d:%02d", minutes, seconds)
	156	}
	157	}
	158
	159	return d.FormatMsg(str)
	160	}
	161
	162	func (d *averageETA) OnCompleteMessage(msg string) {
	163	d.completeMsg = &msg
	164	}
	165
	166	func MaxTolerateTimeNormalizer(maxTolerate time.Duration) TimeNormalizer {
	167	var normalized time.Duration
	168	var lastCall time.Time
	169	return func(remaining time.Duration) time.Duration {
	170	if diff := normalized - remaining; diff <= 0 \|\| diff > maxTolerate \|\| remaining < maxTolerate/2 {
	171	normalized = remaining
	172	lastCall = time.Now()
	173	return remaining
	174	}
	175	normalized -= time.Since(lastCall)
	176	lastCall = time.Now()
	177	return normalized
	178	}
	179	}
	180
	181	func FixedIntervalTimeNormalizer(updInterval int) TimeNormalizer {
	182	var normalized time.Duration
	183	var lastCall time.Time
	184	var count int
	185	return func(remaining time.Duration) time.Duration {
	186	if count == 0 \|\| remaining <= time.Duration(15*time.Second) {
	187	count = updInterval
	188	normalized = remaining
	189	lastCall = time.Now()
	190	return remaining
	191	}
	192	count--
	193	normalized -= time.Since(lastCall)
	194	lastCall = time.Now()
	195	if normalized > 0 {
	196	return normalized
	197	}
	198	return remaining
	199	}
	200	}
	201
	202	func NopNormalizer() TimeNormalizer {
	203	return func(remaining time.Duration) time.Duration {
	204	return remaining
	205	}
	206	}

+66

-0

decor/moving-average.go less more

	0	package decor
	1
	2	import (
	3	"sort"
	4
	5	"github.com/VividCortex/ewma"
	6	)
	7
	8	// MovingAverage is the interface that computes a moving average over a time-
	9	// series stream of numbers. The average may be over a window or exponentially
	10	// decaying.
	11	type MovingAverage interface {
	12	Add(float64)
	13	Value() float64
	14	Set(float64)
	15	}
	16
	17	type medianWindow [3]float64
	18
	19	func (s *medianWindow) Len() int { return len(s) }
	20	func (s *medianWindow) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
	21	func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] }
	22
	23	func (s *medianWindow) Add(value float64) {
	24	s[0], s[1] = s[1], s[2]
	25	s[2] = value
	26	}
	27
	28	func (s *medianWindow) Value() float64 {
	29	tmp := *s
	30	sort.Sort(&tmp)
	31	return tmp[1]
	32	}
	33
	34	func (s *medianWindow) Set(value float64) {
	35	for i := 0; i < len(s); i++ {
	36	s[i] = value
	37	}
	38	}
	39
	40	// NewMedian is fixed last 3 samples median MovingAverage.
	41	func NewMedian() MovingAverage {
	42	return new(medianWindow)
	43	}
	44
	45	type medianEwma struct {
	46	count uint
	47	median MovingAverage
	48	MovingAverage
	49	}
	50
	51	func (s *medianEwma) Add(v float64) {
	52	s.median.Add(v)
	53	if s.count >= 2 {
	54	s.MovingAverage.Add(s.median.Value())
	55	}
	56	s.count++
	57	}
	58
	59	// NewMedianEwma is ewma based MovingAverage, which gets its values from median MovingAverage.
	60	func NewMedianEwma(age ...float64) MovingAverage {
	61	return &medianEwma{
	62	MovingAverage: ewma.NewMovingAverage(age...),
	63	median: NewMedian(),
	64	}
	65	}

+45

-0

decor/name.go less more

	0	package decor
	1
	2	// StaticName returns name decorator.
	3	//
	4	// `name` string to display
	5	//
	6	// `wcc` optional WC config
	7	func StaticName(name string, wcc ...WC) Decorator {
	8	return Name(name, wcc...)
	9	}
	10
	11	// Name returns name decorator.
	12	//
	13	// `name` string to display
	14	//
	15	// `wcc` optional WC config
	16	func Name(name string, wcc ...WC) Decorator {
	17	var wc WC
	18	for _, widthConf := range wcc {
	19	wc = widthConf
	20	}
	21	wc.Init()
	22	d := &nameDecorator{
	23	WC: wc,
	24	msg: name,
	25	}
	26	return d
	27	}
	28
	29	type nameDecorator struct {
	30	WC
	31	msg string
	32	complete *string
	33	}
	34
	35	func (d nameDecorator) Decor(st Statistics) string {
	36	if st.Completed && d.complete != nil {
	37	return d.FormatMsg(*d.complete)
	38	}
	39	return d.FormatMsg(d.msg)
	40	}
	41
	42	func (d *nameDecorator) OnCompleteMessage(msg string) {
	43	d.complete = &msg
	44	}

+39

-0

decor/percentage.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4
	5	"github.com/vbauerster/mpb/internal"
	6	)
	7
	8	// Percentage returns percentage decorator.
	9	//
	10	// `wcc` optional WC config
	11	func Percentage(wcc ...WC) Decorator {
	12	var wc WC
	13	for _, widthConf := range wcc {
	14	wc = widthConf
	15	}
	16	wc.Init()
	17	d := &percentageDecorator{
	18	WC: wc,
	19	}
	20	return d
	21	}
	22
	23	type percentageDecorator struct {
	24	WC
	25	completeMsg *string
	26	}
	27
	28	func (d percentageDecorator) Decor(st Statistics) string {
	29	if st.Completed && d.completeMsg != nil {
	30	return d.FormatMsg(*d.completeMsg)
	31	}
	32	str := fmt.Sprintf("%d %%", internal.Percentage(st.Total, st.Current, 100))
	33	return d.FormatMsg(str)
	34	}
	35
	36	func (d *percentageDecorator) OnCompleteMessage(msg string) {
	37	d.completeMsg = &msg
	38	}

+270

-0

decor/speed.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math"
	6	"strconv"
	7	"strings"
	8	"time"
	9
	10	"github.com/VividCortex/ewma"
	11	)
	12
	13	type SpeedKiB float64
	14
	15	func (s SpeedKiB) Format(st fmt.State, verb rune) {
	16	prec, ok := st.Precision()
	17
	18	if verb == 'd' \|\| !ok {
	19	prec = 0
	20	}
	21	if verb == 'f' && !ok {
	22	prec = 6
	23	}
	24	// retain old beahavior if s verb used
	25	if verb == 's' {
	26	prec = 1
	27	}
	28
	29	var res, unit string
	30	switch {
	31	case s >= TiB:
	32	unit = "TiB/s"
	33	res = strconv.FormatFloat(float64(s)/TiB, 'f', prec, 64)
	34	case s >= GiB:
	35	unit = "GiB/s"
	36	res = strconv.FormatFloat(float64(s)/GiB, 'f', prec, 64)
	37	case s >= MiB:
	38	unit = "MiB/s"
	39	res = strconv.FormatFloat(float64(s)/MiB, 'f', prec, 64)
	40	case s >= KiB:
	41	unit = "KiB/s"
	42	res = strconv.FormatFloat(float64(s)/KiB, 'f', prec, 64)
	43	default:
	44	unit = "b/s"
	45	res = strconv.FormatInt(int64(s), 10)
	46	}
	47
	48	if st.Flag(' ') {
	49	res += " "
	50	}
	51	res += unit
	52
	53	if w, ok := st.Width(); ok {
	54	if len(res) < w {
	55	pad := strings.Repeat(" ", w-len(res))
	56	if st.Flag(int('-')) {
	57	res += pad
	58	} else {
	59	res = pad + res
	60	}
	61	}
	62	}
	63
	64	io.WriteString(st, res)
	65	}
	66
	67	type SpeedKB float64
	68
	69	func (s SpeedKB) Format(st fmt.State, verb rune) {
	70	prec, ok := st.Precision()
	71
	72	if verb == 'd' \|\| !ok {
	73	prec = 0
	74	}
	75	if verb == 'f' && !ok {
	76	prec = 6
	77	}
	78	// retain old beahavior if s verb used
	79	if verb == 's' {
	80	prec = 1
	81	}
	82
	83	var res, unit string
	84	switch {
	85	case s >= TB:
	86	unit = "TB/s"
	87	res = strconv.FormatFloat(float64(s)/TB, 'f', prec, 64)
	88	case s >= GB:
	89	unit = "GB/s"
	90	res = strconv.FormatFloat(float64(s)/GB, 'f', prec, 64)
	91	case s >= MB:
	92	unit = "MB/s"
	93	res = strconv.FormatFloat(float64(s)/MB, 'f', prec, 64)
	94	case s >= KB:
	95	unit = "kB/s"
	96	res = strconv.FormatFloat(float64(s)/KB, 'f', prec, 64)
	97	default:
	98	unit = "b/s"
	99	res = strconv.FormatInt(int64(s), 10)
	100	}
	101
	102	if st.Flag(' ') {
	103	res += " "
	104	}
	105	res += unit
	106
	107	if w, ok := st.Width(); ok {
	108	if len(res) < w {
	109	pad := strings.Repeat(" ", w-len(res))
	110	if st.Flag(int('-')) {
	111	res += pad
	112	} else {
	113	res = pad + res
	114	}
	115	}
	116	}
	117
	118	io.WriteString(st, res)
	119	}
	120
	121	// EwmaSpeed exponential-weighted-moving-average based speed decorator,
	122	// with dynamic unit measure adjustment.
	123	//
	124	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	125	//
	126	// `unitFormat` printf compatible verb for value, like "%f" or "%d"
	127	//
	128	// `average` MovingAverage implementation
	129	//
	130	// `wcc` optional WC config
	131	//
	132	// unitFormat example if UnitKiB is chosen:
	133	//
	134	// "%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
	135	func EwmaSpeed(unit int, unitFormat string, age float64, wcc ...WC) Decorator {
	136	return MovingAverageSpeed(unit, unitFormat, ewma.NewMovingAverage(age), wcc...)
	137	}
	138
	139	// MovingAverageSpeed decorator relies on MovingAverage implementation to calculate its average.
	140	//
	141	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	142	//
	143	// `unitFormat` printf compatible verb for value, like "%f" or "%d"
	144	//
	145	// `average` MovingAverage implementation
	146	//
	147	// `wcc` optional WC config
	148	func MovingAverageSpeed(unit int, unitFormat string, average MovingAverage, wcc ...WC) Decorator {
	149	var wc WC
	150	for _, widthConf := range wcc {
	151	wc = widthConf
	152	}
	153	wc.Init()
	154	d := &movingAverageSpeed{
	155	WC: wc,
	156	unit: unit,
	157	unitFormat: unitFormat,
	158	average: average,
	159	}
	160	return d
	161	}
	162
	163	type movingAverageSpeed struct {
	164	WC
	165	unit int
	166	unitFormat string
	167	average ewma.MovingAverage
	168	msg string
	169	completeMsg *string
	170	}
	171
	172	func (d movingAverageSpeed) Decor(st Statistics) string {
	173	if st.Completed {
	174	if d.completeMsg != nil {
	175	return d.FormatMsg(*d.completeMsg)
	176	}
	177	return d.FormatMsg(d.msg)
	178	}
	179
	180	speed := d.average.Value()
	181	switch d.unit {
	182	case UnitKiB:
	183	d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
	184	case UnitKB:
	185	d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
	186	default:
	187	d.msg = fmt.Sprintf(d.unitFormat, speed)
	188	}
	189
	190	return d.FormatMsg(d.msg)
	191	}
	192
	193	func (s *movingAverageSpeed) NextAmount(n int, wdd ...time.Duration) {
	194	var workDuration time.Duration
	195	for _, wd := range wdd {
	196	workDuration = wd
	197	}
	198	speed := float64(n) / workDuration.Seconds() / 1000
	199	if math.IsInf(speed, 0) \|\| math.IsNaN(speed) {
	200	return
	201	}
	202	s.average.Add(speed)
	203	}
	204
	205	func (d *movingAverageSpeed) OnCompleteMessage(msg string) {
	206	d.completeMsg = &msg
	207	}
	208
	209	// AverageSpeed decorator with dynamic unit measure adjustment.
	210	//
	211	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
	212	//
	213	// `unitFormat` printf compatible verb for value, like "%f" or "%d"
	214	//
	215	// `wcc` optional WC config
	216	//
	217	// unitFormat example if UnitKiB is chosen:
	218	//
	219	// "%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
	220	func AverageSpeed(unit int, unitFormat string, wcc ...WC) Decorator {
	221	var wc WC
	222	for _, widthConf := range wcc {
	223	wc = widthConf
	224	}
	225	wc.Init()
	226	d := &averageSpeed{
	227	WC: wc,
	228	unit: unit,
	229	unitFormat: unitFormat,
	230	startTime: time.Now(),
	231	}
	232	return d
	233	}
	234
	235	type averageSpeed struct {
	236	WC
	237	unit int
	238	unitFormat string
	239	startTime time.Time
	240	msg string
	241	completeMsg *string
	242	}
	243
	244	func (d averageSpeed) Decor(st Statistics) string {
	245	if st.Completed {
	246	if d.completeMsg != nil {
	247	return d.FormatMsg(*d.completeMsg)
	248	}
	249	return d.FormatMsg(d.msg)
	250	}
	251
	252	timeElapsed := time.Since(d.startTime)
	253	speed := float64(st.Current) / timeElapsed.Seconds()
	254
	255	switch d.unit {
	256	case UnitKiB:
	257	d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
	258	case UnitKB:
	259	d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
	260	default:
	261	d.msg = fmt.Sprintf(d.unitFormat, speed)
	262	}
	263
	264	return d.FormatMsg(d.msg)
	265	}
	266
	267	func (d *averageSpeed) OnCompleteMessage(msg string) {
	268	d.completeMsg = &msg
	269	}

+142

-0

decor/speed_test.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"testing"
	5	)
	6
	7	func TestSpeedKiB(t *testing.T) {
	8	cases := map[string]struct {
	9	value int64
	10	verb string
	11	expected string
	12	}{
	13	"verb %f": {12345678, "%f", "11.773756MiB/s"},
	14	"verb %.0f": {12345678, "%.0f", "12MiB/s"},
	15	"verb %.1f": {12345678, "%.1f", "11.8MiB/s"},
	16	"verb %.2f": {12345678, "%.2f", "11.77MiB/s"},
	17	"verb %.3f": {12345678, "%.3f", "11.774MiB/s"},
	18
	19	"verb % f": {12345678, "% f", "11.773756 MiB/s"},
	20	"verb % .0f": {12345678, "% .0f", "12 MiB/s"},
	21	"verb % .1f": {12345678, "% .1f", "11.8 MiB/s"},
	22	"verb % .2f": {12345678, "% .2f", "11.77 MiB/s"},
	23	"verb % .3f": {12345678, "% .3f", "11.774 MiB/s"},
	24
	25	"verb %10.f": {12345678, "%10.f", " 12MiB/s"},
	26	"verb %10.0f": {12345678, "%10.0f", " 12MiB/s"},
	27	"verb %10.1f": {12345678, "%10.1f", " 11.8MiB/s"},
	28	"verb %10.2f": {12345678, "%10.2f", "11.77MiB/s"},
	29	"verb %10.3f": {12345678, "%10.3f", "11.774MiB/s"},
	30
	31	"verb % 10.f": {12345678, "% 10.f", " 12 MiB/s"},
	32	"verb % 10.0f": {12345678, "% 10.0f", " 12 MiB/s"},
	33	"verb % 10.1f": {12345678, "% 10.1f", "11.8 MiB/s"},
	34
	35	"verb %-10.f": {12345678, "%-10.f", "12MiB/s "},
	36	"verb %-10.0f": {12345678, "%-10.0f", "12MiB/s "},
	37	"verb %-10.1f": {12345678, "%-10.1f", "11.8MiB/s "},
	38	"verb %-10.2f": {12345678, "%10.2f", "11.77MiB/s"},
	39	"verb %-10.3f": {12345678, "%10.3f", "11.774MiB/s"},
	40
	41	"verb % -10.f": {12345678, "% -10.f", "12 MiB/s "},
	42	"verb % -10.0f": {12345678, "% -10.0f", "12 MiB/s "},
	43	"verb % -10.1f": {12345678, "% -10.1f", "11.8 MiB/s"},
	44
	45	"1000 %f": {1000, "%f", "1000b/s"},
	46	"1000 %d": {1000, "%d", "1000b/s"},
	47	"1000 %s": {1000, "%s", "1000b/s"},
	48	"1024 %f": {1024, "%f", "1.000000KiB/s"},
	49	"1024 %d": {1024, "%d", "1KiB/s"},
	50	"1024 %.1f": {1024, "%.1f", "1.0KiB/s"},
	51	"1024 %s": {1024, "%s", "1.0KiB/s"},
	52	"3MiB/s+140KiB/s %f": {3MiB + 140*KiB, "%f", "3.136719MiB/s"},
	53	"3MiB/s+140KiB/s %d": {3MiB + 140*KiB, "%d", "3MiB/s"},
	54	"3MiB/s+140KiB/s %.1f": {3MiB + 140*KiB, "%.1f", "3.1MiB/s"},
	55	"3MiB/s+140KiB/s %s": {3MiB + 140*KiB, "%s", "3.1MiB/s"},
	56	"2GiB/s %f": {2 GiB, "%f", "2.000000GiB/s"},
	57	"2GiB/s %d": {2 GiB, "%d", "2GiB/s"},
	58	"2GiB/s %.1f": {2 GiB, "%.1f", "2.0GiB/s"},
	59	"2GiB/s %s": {2 GiB, "%s", "2.0GiB/s"},
	60	"4TiB/s %f": {4 TiB, "%f", "4.000000TiB/s"},
	61	"4TiB/s %d": {4 TiB, "%d", "4TiB/s"},
	62	"4TiB/s %.1f": {4 TiB, "%.1f", "4.0TiB/s"},
	63	"4TiB/s %s": {4 TiB, "%s", "4.0TiB/s"},
	64	}
	65	for name, tc := range cases {
	66	t.Run(name, func(t *testing.T) {
	67	got := fmt.Sprintf(tc.verb, SpeedKiB(tc.value))
	68	if got != tc.expected {
	69	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	70	}
	71	})
	72	}
	73	}
	74
	75	func TestSpeedKB(t *testing.T) {
	76	cases := map[string]struct {
	77	value int64
	78	verb string
	79	expected string
	80	}{
	81	"verb %f": {12345678, "%f", "12.345678MB/s"},
	82	"verb %.0f": {12345678, "%.0f", "12MB/s"},
	83	"verb %.1f": {12345678, "%.1f", "12.3MB/s"},
	84	"verb %.2f": {12345678, "%.2f", "12.35MB/s"},
	85	"verb %.3f": {12345678, "%.3f", "12.346MB/s"},
	86
	87	"verb % f": {12345678, "% f", "12.345678 MB/s"},
	88	"verb % .0f": {12345678, "% .0f", "12 MB/s"},
	89	"verb % .1f": {12345678, "% .1f", "12.3 MB/s"},
	90	"verb % .2f": {12345678, "% .2f", "12.35 MB/s"},
	91	"verb % .3f": {12345678, "% .3f", "12.346 MB/s"},
	92
	93	"verb %10.f": {12345678, "%10.f", " 12MB/s"},
	94	"verb %10.0f": {12345678, "%10.0f", " 12MB/s"},
	95	"verb %10.1f": {12345678, "%10.1f", " 12.3MB/s"},
	96	"verb %10.2f": {12345678, "%10.2f", " 12.35MB/s"},
	97	"verb %10.3f": {12345678, "%10.3f", "12.346MB/s"},
	98
	99	"verb % 10.f": {12345678, "% 10.f", " 12 MB/s"},
	100	"verb % 10.0f": {12345678, "% 10.0f", " 12 MB/s"},
	101	"verb % 10.1f": {12345678, "% 10.1f", " 12.3 MB/s"},
	102
	103	"verb %-10.f": {12345678, "%-10.f", "12MB/s "},
	104	"verb %-10.0f": {12345678, "%-10.0f", "12MB/s "},
	105	"verb %-10.1f": {12345678, "%-10.1f", "12.3MB/s "},
	106	"verb %-10.2f": {12345678, "%10.2f", " 12.35MB/s"},
	107	"verb %-10.3f": {12345678, "%10.3f", "12.346MB/s"},
	108
	109	"verb % -10.f": {12345678, "% -10.f", "12 MB/s "},
	110	"verb % -10.0f": {12345678, "% -10.0f", "12 MB/s "},
	111	"verb % -10.1f": {12345678, "% -10.1f", "12.3 MB/s "},
	112
	113	"1000 %f": {1000, "%f", "1.000000kB/s"},
	114	"1000 %d": {1000, "%d", "1kB/s"},
	115	"1000 %s": {1000, "%s", "1.0kB/s"},
	116	"1024 %f": {1024, "%f", "1.024000kB/s"},
	117	"1024 %d": {1024, "%d", "1kB/s"},
	118	"1024 %.1f": {1024, "%.1f", "1.0kB/s"},
	119	"1024 %s": {1024, "%s", "1.0kB/s"},
	120	"3MB/s+140KB/s %f": {3MB + 140KB, "%f", "3.140000MB/s"},
	121	"3MB/s+140KB/s %d": {3MB + 140KB, "%d", "3MB/s"},
	122	"3MB/s+140KB/s %.1f": {3MB + 140KB, "%.1f", "3.1MB/s"},
	123	"3MB/s+140KB/s %s": {3MB + 140KB, "%s", "3.1MB/s"},
	124	"2GB/s %f": {2 GB, "%f", "2.000000GB/s"},
	125	"2GB/s %d": {2 GB, "%d", "2GB/s"},
	126	"2GB/s %.1f": {2 GB, "%.1f", "2.0GB/s"},
	127	"2GB/s %s": {2 GB, "%s", "2.0GB/s"},
	128	"4TB/s %f": {4 TB, "%f", "4.000000TB/s"},
	129	"4TB/s %d": {4 TB, "%d", "4TB/s"},
	130	"4TB/s %.1f": {4 TB, "%.1f", "4.0TB/s"},
	131	"4TB/s %s": {4 TB, "%s", "4.0TB/s"},
	132	}
	133	for name, tc := range cases {
	134	t.Run(name, func(t *testing.T) {
	135	got := fmt.Sprintf(tc.verb, SpeedKB(tc.value))
	136	if got != tc.expected {
	137	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	138	}
	139	})
	140	}
	141	}

+219

-0

decorators_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"sync"
	4	"testing"
	5
	6	. "github.com/vbauerster/mpb"
	7	"github.com/vbauerster/mpb/decor"
	8	)
	9
	10	func TestNameDecorator(t *testing.T) {
	11	tests := []struct {
	12	decorator decor.Decorator
	13	want string
	14	}{
	15	{
	16	decorator: decor.Name("Test"),
	17	want: "Test",
	18	},
	19	{
	20	decorator: decor.Name("Test", decor.WC{W: len("Test")}),
	21	want: "Test",
	22	},
	23	{
	24	decorator: decor.Name("Test", decor.WC{W: 10}),
	25	want: " Test",
	26	},
	27	{
	28	decorator: decor.Name("Test", decor.WC{W: 10, C: decor.DidentRight}),
	29	want: "Test ",
	30	},
	31	}
	32
	33	for _, test := range tests {
	34	got := test.decorator.Decor(new(decor.Statistics))
	35	if got != test.want {
	36	t.Errorf("Want: %q, Got: %q\n", test.want, got)
	37	}
	38	}
	39	}
	40
	41	type step struct {
	42	stat *decor.Statistics
	43	decorator decor.Decorator
	44	want string
	45	}
	46
	47	func TestPercentageDwidthSync(t *testing.T) {
	48
	49	testCases := [][]step{
	50	[]step{
	51	{
	52	&decor.Statistics{Total: 100, Current: 8},
	53	decor.Percentage(decor.WCSyncWidth),
	54	"8 %",
	55	},
	56	{
	57	&decor.Statistics{Total: 100, Current: 9},
	58	decor.Percentage(decor.WCSyncWidth),
	59	"9 %",
	60	},
	61	},
	62	[]step{
	63	{
	64	&decor.Statistics{Total: 100, Current: 9},
	65	decor.Percentage(decor.WCSyncWidth),
	66	" 9 %",
	67	},
	68	{
	69	&decor.Statistics{Total: 100, Current: 10},
	70	decor.Percentage(decor.WCSyncWidth),
	71	"10 %",
	72	},
	73	},
	74	[]step{
	75	{
	76	&decor.Statistics{Total: 100, Current: 9},
	77	decor.Percentage(decor.WCSyncWidth),
	78	" 9 %",
	79	},
	80	{
	81	&decor.Statistics{Total: 100, Current: 100},
	82	decor.Percentage(decor.WCSyncWidth),
	83	"100 %",
	84	},
	85	},
	86	}
	87
	88	testDecoratorConcurrently(t, testCases)
	89	}
	90
	91	func TestPercentageDwidthSyncDidentRight(t *testing.T) {
	92
	93	testCases := [][]step{
	94	[]step{
	95	{
	96	&decor.Statistics{Total: 100, Current: 8},
	97	decor.Percentage(decor.WCSyncWidthR),
	98	"8 %",
	99	},
	100	{
	101	&decor.Statistics{Total: 100, Current: 9},
	102	decor.Percentage(decor.WCSyncWidthR),
	103	"9 %",
	104	},
	105	},
	106	[]step{
	107	{
	108	&decor.Statistics{Total: 100, Current: 9},
	109	decor.Percentage(decor.WCSyncWidthR),
	110	"9 % ",
	111	},
	112	{
	113	&decor.Statistics{Total: 100, Current: 10},
	114	decor.Percentage(decor.WCSyncWidthR),
	115	"10 %",
	116	},
	117	},
	118	[]step{
	119	{
	120	&decor.Statistics{Total: 100, Current: 9},
	121	decor.Percentage(decor.WCSyncWidthR),
	122	"9 % ",
	123	},
	124	{
	125	&decor.Statistics{Total: 100, Current: 100},
	126	decor.Percentage(decor.WCSyncWidthR),
	127	"100 %",
	128	},
	129	},
	130	}
	131
	132	testDecoratorConcurrently(t, testCases)
	133	}
	134
	135	func TestPercentageDSyncSpace(t *testing.T) {
	136
	137	testCases := [][]step{
	138	[]step{
	139	{
	140	&decor.Statistics{Total: 100, Current: 8},
	141	decor.Percentage(decor.WCSyncSpace),
	142	" 8 %",
	143	},
	144	{
	145	&decor.Statistics{Total: 100, Current: 9},
	146	decor.Percentage(decor.WCSyncSpace),
	147	" 9 %",
	148	},
	149	},
	150	[]step{
	151	{
	152	&decor.Statistics{Total: 100, Current: 9},
	153	decor.Percentage(decor.WCSyncSpace),
	154	" 9 %",
	155	},
	156	{
	157	&decor.Statistics{Total: 100, Current: 10},
	158	decor.Percentage(decor.WCSyncSpace),
	159	" 10 %",
	160	},
	161	},
	162	[]step{
	163	{
	164	&decor.Statistics{Total: 100, Current: 9},
	165	decor.Percentage(decor.WCSyncSpace),
	166	" 9 %",
	167	},
	168	{
	169	&decor.Statistics{Total: 100, Current: 100},
	170	decor.Percentage(decor.WCSyncSpace),
	171	" 100 %",
	172	},
	173	},
	174	}
	175
	176	testDecoratorConcurrently(t, testCases)
	177	}
	178
	179	func testDecoratorConcurrently(t *testing.T, testCases [][]step) {
	180	if len(testCases) == 0 {
	181	t.Fail()
	182	}
	183
	184	numBars := len(testCases[0])
	185	var wg sync.WaitGroup
	186	for _, columnCase := range testCases {
	187	wg.Add(numBars)
	188	SyncWidth(toSyncMatrix(columnCase))
	189	gott := make([]chan string, numBars)
	190	for i := 0; i < numBars; i++ {
	191	gott[i] = make(chan string, 1)
	192	go func(s step, ch chan string) {
	193	defer wg.Done()
	194	ch <- s.decorator.Decor(s.stat)
	195	}(columnCase[i], gott[i])
	196	}
	197	wg.Wait()
	198
	199	for i, ch := range gott {
	200	got := <-ch
	201	want := columnCase[i].want
	202	if got != want {
	203	t.Errorf("Want: %q, Got: %q\n", want, got)
	204	}
	205	}
	206
	207	}
	208	}
	209
	210	func toSyncMatrix(ss []step) map[int][]chan int {
	211	var column []chan int
	212	for _, s := range ss {
	213	if ok, ch := s.decorator.Syncable(); ok {
	214	column = append(column, ch)
	215	}
	216	}
	217	return map[int][]chan int{0: column}
	218	}

+6

-0

doc.go less more

	0	// Copyright (C) 2016-2018 Vladimir Bauer
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// Package mpb is a library for rendering progress bars in terminal applications.
	5	package mpb

+212

-0

draw_test.go less more

	0	package mpb
	1
	2	import (
	3	"bytes"
	4	"testing"
	5	)
	6
	7	func TestDraw(t *testing.T) {
	8	// key is termWidth
	9	testSuite := map[int]map[string]struct {
	10	total, current int64
	11	barWidth int
	12	barRefill *refill
	13	want string
	14	}{
	15	100: {
	16	"t,c,bw{100,100,0}": {
	17	total: 100,
	18	current: 0,
	19	barWidth: 100,
	20	want: "[--------------------------------------------------------------------------------------------------]",
	21	},
	22	"t,c,bw{100,1,100}": {
	23	total: 100,
	24	current: 1,
	25	barWidth: 100,
	26	want: "[>-------------------------------------------------------------------------------------------------]",
	27	},
	28	"t,c,bw{100,40,100}": {
	29	total: 100,
	30	current: 40,
	31	barWidth: 100,
	32	want: "[======================================>-----------------------------------------------------------]",
	33	},
	34	"t,c,bw{100,40,100}refill{'+', 32}": {
	35	total: 100,
	36	current: 40,
	37	barWidth: 100,
	38	barRefill: &refill{'+', 32},
	39	want: "[+++++++++++++++++++++++++++++++=======>-----------------------------------------------------------]",
	40	},
	41	"t,c,bw{100,99,100}": {
	42	total: 100,
	43	current: 99,
	44	barWidth: 100,
	45	want: "[================================================================================================>-]",
	46	},
	47	"t,c,bw{100,100,100}": {
	48	total: 100,
	49	current: 100,
	50	barWidth: 100,
	51	want: "[==================================================================================================]",
	52	},
	53	},
	54	2: {
	55	"t,c,bw{0,0,100}": {
	56	barWidth: 100,
	57	want: "[]",
	58	},
	59	"t,c,bw{60,20,80}": {
	60	total: 60,
	61	current: 20,
	62	barWidth: 80,
	63	want: "[]",
	64	},
	65	},
	66	3: {
	67	"t,c,bw{100,20,100}": {
	68	total: 100,
	69	current: 20,
	70	barWidth: 100,
	71	want: "[-]",
	72	},
	73	"t,c,bw{100,98,100}": {
	74	total: 100,
	75	current: 98,
	76	barWidth: 100,
	77	want: "[=]",
	78	},
	79	"t,c,bw{100,100,100}": {
	80	total: 100,
	81	current: 100,
	82	barWidth: 100,
	83	want: "[=]",
	84	},
	85	},
	86	5: {
	87	"t,c,bw{100,20,100}": {
	88	total: 100,
	89	current: 20,
	90	barWidth: 100,
	91	want: "[>--]",
	92	},
	93	"t,c,bw{100,98,100}": {
	94	total: 100,
	95	current: 98,
	96	barWidth: 100,
	97	want: "[===]",
	98	},
	99	"t,c,bw{100,100,100}": {
	100	total: 100,
	101	current: 100,
	102	barWidth: 100,
	103	want: "[===]",
	104	},
	105	},
	106	6: {
	107	"t,c,bw{100,20,100}": {
	108	total: 100,
	109	current: 20,
	110	barWidth: 100,
	111	want: "[>---]",
	112	},
	113	"t,c,bw{100,98,100}": {
	114	total: 100,
	115	current: 98,
	116	barWidth: 100,
	117	want: "[====]",
	118	},
	119	"t,c,bw{100,100,100}": {
	120	total: 100,
	121	current: 100,
	122	barWidth: 100,
	123	want: "[====]",
	124	},
	125	},
	126	20: {
	127	"t,c,bw{100,20,100}": {
	128	total: 100,
	129	current: 20,
	130	barWidth: 100,
	131	want: "[===>--------------]",
	132	},
	133	"t,c,bw{100,60,100}": {
	134	total: 100,
	135	current: 60,
	136	barWidth: 100,
	137	want: "[==========>-------]",
	138	},
	139	"t,c,bw{100,98,100}": {
	140	total: 100,
	141	current: 98,
	142	barWidth: 100,
	143	want: "[==================]",
	144	},
	145	"t,c,bw{100,100,100}": {
	146	total: 100,
	147	current: 100,
	148	barWidth: 100,
	149	want: "[==================]",
	150	},
	151	},
	152	50: {
	153	"t,c,bw{100,20,100}": {
	154	total: 100,
	155	current: 20,
	156	barWidth: 100,
	157	want: "[=========>--------------------------------------]",
	158	},
	159	"t,c,bw{100,60,100}": {
	160	total: 100,
	161	current: 60,
	162	barWidth: 100,
	163	want: "[============================>-------------------]",
	164	},
	165	"t,c,bw{100,98,100}": {
	166	total: 100,
	167	current: 98,
	168	barWidth: 100,
	169	want: "[==============================================>-]",
	170	},
	171	"t,c,bw{100,100,100}": {
	172	total: 100,
	173	current: 100,
	174	barWidth: 100,
	175	want: "[================================================]",
	176	},
	177	},
	178	}
	179
	180	var tmpBuf bytes.Buffer
	181	for termWidth, cases := range testSuite {
	182	for name, tc := range cases {
	183	s := newTestState()
	184	s.width = tc.barWidth
	185	s.total = tc.total
	186	s.current = tc.current
	187	if tc.barRefill != nil {
	188	s.refill = tc.barRefill
	189	}
	190	tmpBuf.Reset()
	191	tmpBuf.ReadFrom(s.draw(termWidth))
	192	got := tmpBuf.String()
	193	want := tc.want + "\n"
	194	if got != want {
	195	t.Errorf("termWidth %d; %s: want: %s %d, got: %s %d\n", termWidth, name, want, len(want), got, len(got))
	196	}
	197	}
	198	}
	199	}
	200
	201	func newTestState() *bState {
	202	s := &bState{
	203	trimLeftSpace: true,
	204	trimRightSpace: true,
	205	bufP: new(bytes.Buffer),
	206	bufB: new(bytes.Buffer),
	207	bufA: new(bytes.Buffer),
	208	}
	209	s.runes = strToBarRunes(pformat)
	210	return s
	211	}

+84

-0

example_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"io"
	4	"io/ioutil"
	5	"math/rand"
	6	"net/http"
	7	"time"
	8
	9	"github.com/vbauerster/mpb"
	10	"github.com/vbauerster/mpb/decor"
	11	)
	12
	13	func Example() {
	14	p := mpb.New(
	15	// override default (80) width
	16	mpb.WithWidth(64),
	17	// override default "[=>-]" format
	18	mpb.WithFormat("╢▌▌░╟"),
	19	// override default 120ms refresh rate
	20	mpb.WithRefreshRate(180*time.Millisecond),
	21	)
	22
	23	total := 100
	24	name := "Single Bar:"
	25	// adding a single bar
	26	bar := p.AddBar(int64(total),
	27	mpb.PrependDecorators(
	28	// display our name with one space on the right
	29	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
	30	// replace ETA decorator with "done" message, OnComplete event
	31	decor.OnComplete(
	32	// ETA decorator with ewma age of 60, and width reservation of 4
	33	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
	34	),
	35	),
	36	mpb.AppendDecorators(decor.Percentage()),
	37	)
	38	// simulating some work
	39	max := 100 * time.Millisecond
	40	for i := 0; i < total; i++ {
	41	start := time.Now()
	42	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	43	// ewma based decorators require work duration measurement
	44	bar.IncrBy(1, time.Since(start))
	45	}
	46	// wait for our bar to complete and flush
	47	p.Wait()
	48	}
	49
	50	func ExampleBar_Completed() {
	51	p := mpb.New()
	52	bar := p.AddBar(100)
	53
	54	max := 100 * time.Millisecond
	55	for !bar.Completed() {
	56	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	57	bar.Increment()
	58	}
	59
	60	p.Wait()
	61	}
	62
	63	func ExampleBar_ProxyReader() {
	64	p := mpb.New()
	65	// make http get request, ignoring errors
	66	resp, _ := http.Get("https://homebrew.bintray.com/bottles/libtiff-4.0.7.sierra.bottle.tar.gz")
	67	defer resp.Body.Close()
	68
	69	// Assuming ContentLength > 0
	70	bar := p.AddBar(resp.ContentLength,
	71	mpb.AppendDecorators(
	72	decor.CountersKibiByte("%6.1f / %6.1f"),
	73	),
	74	)
	75
	76	// create proxy reader
	77	reader := bar.ProxyReader(resp.Body)
	78
	79	// and copy from reader, ignoring errors
	80	io.Copy(ioutil.Discard, reader)
	81
	82	p.Wait()
	83	}

+60

-0

examples/barNewLineExtend/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb"
	10	"github.com/vbauerster/mpb/decor"
	11	)
	12
	13	func init() {
	14	rand.Seed(time.Now().UnixNano())
	15	}
	16
	17	func main() {
	18	var wg sync.WaitGroup
	19	p := mpb.New(mpb.WithWaitGroup(&wg))
	20	total, numBars := 100, 3
	21	wg.Add(numBars)
	22
	23	for i := 0; i < numBars; i++ {
	24	name := fmt.Sprintf("Bar#%d:", i)
	25	efn := func(w io.Writer, s *decor.Statistics) {
	26	if s.Completed {
	27	fmt.Fprintf(w, "Bar id: %d has been completed\n", s.ID)
	28	}
	29	}
	30	bar := p.AddBar(int64(total), mpb.BarNewLineExtend(efn),
	31	mpb.PrependDecorators(
	32	// simple name decorator
	33	decor.Name(name),
	34	// decor.DSyncWidth bit enables column width synchronization
	35	decor.Percentage(decor.WCSyncSpace),
	36	),
	37	mpb.AppendDecorators(
	38	// replace ETA decorator with "done" message, OnComplete event
	39	decor.OnComplete(
	40	// ETA decorator with ewma age of 60
	41	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	42	),
	43	),
	44	)
	45	// simulating some work
	46	go func() {
	47	defer wg.Done()
	48	max := 100 * time.Millisecond
	49	for i := 0; i < total; i++ {
	50	start := time.Now()
	51	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	52	// ewma based decorators require work duration measurement
	53	bar.IncrBy(1, time.Since(start))
	54	}
	55	}()
	56	}
	57	// wait for all bars to complete and flush
	58	p.Wait()
	59	}

+58

-0

examples/cancel/main.go less more

	0	//+build go1.7
	1
	2	package main
	3
	4	import (
	5	"context"
	6	"fmt"
	7	"math/rand"
	8	"sync"
	9	"time"
	10
	11	"github.com/vbauerster/mpb"
	12	"github.com/vbauerster/mpb/decor"
	13	)
	14
	15	func init() {
	16	rand.Seed(time.Now().UnixNano())
	17	}
	18
	19	func main() {
	20	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	21	defer cancel()
	22
	23	var wg sync.WaitGroup
	24	p := mpb.New(
	25	mpb.WithWaitGroup(&wg),
	26	mpb.WithContext(ctx),
	27	)
	28	total := 300
	29	numBars := 3
	30	wg.Add(numBars)
	31
	32	for i := 0; i < numBars; i++ {
	33	name := fmt.Sprintf("Bar#%d:", i)
	34	bar := p.AddBar(int64(total),
	35	mpb.PrependDecorators(
	36	decor.Name(name),
	37	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	38	),
	39	mpb.AppendDecorators(
	40	decor.Percentage(decor.WC{W: 5}),
	41	),
	42	)
	43
	44	go func() {
	45	defer wg.Done()
	46	max := 100 * time.Millisecond
	47	for !bar.Completed() {
	48	start := time.Now()
	49	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	50	// ewma based decorators require work duration measurement
	51	bar.IncrBy(1, time.Since(start))
	52	}
	53	}()
	54	}
	55
	56	p.Wait()
	57	}

+79

-0

examples/complex/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	func init() {
	13	rand.Seed(time.Now().UnixNano())
	14	}
	15
	16	func main() {
	17	doneWg := new(sync.WaitGroup)
	18	p := mpb.New(mpb.WithWidth(64), mpb.WithWaitGroup(doneWg))
	19	numBars := 4
	20
	21	var bars []*mpb.Bar
	22	var downloadWgg []*sync.WaitGroup
	23	for i := 0; i < numBars; i++ {
	24	wg := new(sync.WaitGroup)
	25	wg.Add(1)
	26	downloadWgg = append(downloadWgg, wg)
	27	task := fmt.Sprintf("Task#%02d:", i)
	28	job := "downloading"
	29	b := p.AddBar(rand.Int63n(201)+100,
	30	mpb.BarRemoveOnComplete(),
	31	mpb.PrependDecorators(
	32	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
	33	decor.Name(job, decor.WCSyncSpaceR),
	34	decor.CountersNoUnit("%d / %d", decor.WCSyncWidth),
	35	),
	36	mpb.AppendDecorators(decor.Percentage(decor.WC{W: 5})),
	37	)
	38	go newTask(wg, b, i+1)
	39	bars = append(bars, b)
	40	}
	41
	42	for i := 0; i < numBars; i++ {
	43	doneWg.Add(1)
	44	i := i
	45	go func() {
	46	task := fmt.Sprintf("Task#%02d:", i)
	47	job := "installing"
	48	// preparing delayed bars
	49	b := p.AddBar(rand.Int63n(101)+100,
	50	mpb.BarReplaceOnComplete(bars[i]),
	51	mpb.BarClearOnComplete(),
	52	mpb.PrependDecorators(
	53	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
	54	decor.OnComplete(decor.Name(job, decor.WCSyncSpaceR), "done!"),
	55	decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_MMSS, 60, decor.WCSyncWidth), "")),
	56	mpb.AppendDecorators(
	57	decor.OnComplete(decor.Percentage(decor.WC{W: 5}), ""),
	58	),
	59	)
	60	// waiting for download to complete, before starting install job
	61	downloadWgg[i].Wait()
	62	go newTask(doneWg, b, numBars-i)
	63	}()
	64	}
	65
	66	p.Wait()
	67	}
	68
	69	func newTask(wg sync.WaitGroup, b mpb.Bar, incrBy int) {
	70	defer wg.Done()
	71	max := 100 * time.Millisecond
	72	for !b.Completed() {
	73	start := time.Now()
	74	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	75	// ewma based decorators require work duration measurement
	76	b.IncrBy(incrBy, time.Since(start))
	77	}
	78	}

+52

-0

examples/dynTotal/main.go less more

	0	package main
	1
	2	import (
	3	"io"
	4	"math/rand"
	5	"time"
	6
	7	"github.com/vbauerster/mpb"
	8	"github.com/vbauerster/mpb/decor"
	9	)
	10
	11	func init() {
	12	rand.Seed(time.Now().UnixNano())
	13	}
	14
	15	func main() {
	16	p := mpb.New(mpb.WithWidth(64))
	17
	18	var total int64
	19	bar := p.AddBar(total,
	20	mpb.PrependDecorators(decor.Counters(decor.UnitKiB, "% .1f / % .1f")),
	21	mpb.AppendDecorators(decor.Percentage()),
	22	)
	23
	24	maxSleep := 100 * time.Millisecond
	25	read := makeStream(200)
	26	for {
	27	n, err := read()
	28	total += int64(n)
	29	time.Sleep(time.Duration(rand.Intn(10)+1) * maxSleep / 10)
	30	bar.IncrBy(n)
	31	if err == io.EOF {
	32	// total is known, final=true
	33	bar.SetTotal(total, true)
	34	break
	35	}
	36	// total is unknown, final=false
	37	bar.SetTotal(total+2048, false)
	38	}
	39
	40	p.Wait()
	41	}
	42
	43	func makeStream(limit int) func() (int, error) {
	44	return func() (int, error) {
	45	if limit <= 0 {
	46	return 0, io.EOF
	47	}
	48	limit--
	49	return rand.Intn(1024) + 1, nil
	50	}
	51	}

+1

-0

examples/gifs/godEMrCZmJkHYH1X9dN4Nm0U7.svg less more

0

+1

-0

examples/gifs/hIpTa3A5rQz65ssiVuRJu87X6.svg less more

0

+1

-0

examples/gifs/wHzf1M7sd7B3zVa2scBMnjqRf.svg less more

0

+83

-0

examples/io/multiple/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"log"
	6	"net/http"
	7	"os"
	8	"path/filepath"
	9	"sync"
	10
	11	"github.com/vbauerster/mpb"
	12	"github.com/vbauerster/mpb/decor"
	13	)
	14
	15	func main() {
	16	log.SetOutput(os.Stderr)
	17
	18	url1 := "https://homebrew.bintray.com/bottles/youtube-dl-2016.12.12.sierra.bottle.tar.gz"
	19	url2 := "https://homebrew.bintray.com/bottles/libtiff-4.0.7.sierra.bottle.tar.gz"
	20
	21	var wg sync.WaitGroup
	22	p := mpb.New(mpb.WithWidth(64), mpb.WithWaitGroup(&wg))
	23
	24	for i, url := range [...]string{url1, url2} {
	25	wg.Add(1)
	26	name := fmt.Sprintf("url%d:", i+1)
	27	go download(&wg, p, name, url, i)
	28	}
	29
	30	p.Wait()
	31	}
	32
	33	func download(wg sync.WaitGroup, p mpb.Progress, name, url string, n int) {
	34	defer wg.Done()
	35	resp, err := http.Get(url)
	36	if err != nil {
	37	log.Printf("%s: %v", name, err)
	38	return
	39	}
	40	defer resp.Body.Close()
	41
	42	if resp.StatusCode != http.StatusOK {
	43	err = fmt.Errorf("non-200 status: %s", resp.Status)
	44	log.Printf("%s: %v", name, err)
	45	return
	46	}
	47
	48	size := resp.ContentLength
	49
	50	// create dest
	51	destName := filepath.Base(url)
	52	dest, err := os.Create(destName)
	53	if err != nil {
	54	err = fmt.Errorf("Can't create %s: %v", destName, err)
	55	log.Printf("%s: %v", name, err)
	56	return
	57	}
	58
	59	// create bar with appropriate decorators
	60	bar := p.AddBar(size, mpb.BarPriority(n),
	61	mpb.PrependDecorators(
	62	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
	63	decor.CountersKibiByte("%6.1f / %6.1f", decor.WCSyncWidth),
	64	),
	65	mpb.AppendDecorators(
	66	decor.EwmaETA(decor.ET_STYLE_HHMMSS, 1024*4, decor.WCSyncWidth),
	67	decor.AverageSpeed(decor.UnitKiB, "% .2f"),
	68	),
	69	)
	70
	71	// create proxy reader
	72	reader := bar.ProxyReader(resp.Body)
	73	// and copy from reader
	74	_, err = io.Copy(dest, reader)
	75
	76	if e := dest.Close(); err == nil {
	77	err = e
	78	}
	79	if err != nil {
	80	log.Printf("%s: %v", name, err)
	81	}
	82	}

+64

-0

examples/io/single/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"net/http"
	6	"os"
	7	"path/filepath"
	8	"time"
	9
	10	"github.com/vbauerster/mpb"
	11	"github.com/vbauerster/mpb/decor"
	12	)
	13
	14	func main() {
	15	url := "https://github.com/onivim/oni/releases/download/v0.3.4/Oni-0.3.4-amd64-linux.deb"
	16
	17	resp, err := http.Get(url)
	18	if err != nil {
	19	panic(err)
	20	}
	21	defer resp.Body.Close()
	22
	23	if resp.StatusCode != http.StatusOK {
	24	fmt.Printf("Server return non-200 status: %s\n", resp.Status)
	25	return
	26	}
	27
	28	size := resp.ContentLength
	29
	30	// create dest
	31	destName := filepath.Base(url)
	32	dest, err := os.Create(destName)
	33	if err != nil {
	34	fmt.Printf("Can't create %s: %v\n", destName, err)
	35	return
	36	}
	37	defer dest.Close()
	38
	39	p := mpb.New(
	40	mpb.WithWidth(60),
	41	mpb.WithFormat("[=>-\|"),
	42	mpb.WithRefreshRate(180*time.Millisecond),
	43	)
	44
	45	bar := p.AddBar(size,
	46	mpb.PrependDecorators(
	47	decor.CountersKibiByte("% 6.1f / % 6.1f"),
	48	),
	49	mpb.AppendDecorators(
	50	decor.EwmaETA(decor.ET_STYLE_MMSS, float64(size)/2048),
	51	decor.Name(" ] "),
	52	decor.AverageSpeed(decor.UnitKiB, "% .2f"),
	53	),
	54	)
	55
	56	// create proxy reader
	57	reader := bar.ProxyReader(resp.Body)
	58
	59	// and copy from reader, ignoring errors
	60	io.Copy(dest, reader)
	61
	62	p.Wait()
	63	}

+57

-0

examples/panic/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"os"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
	15
	16	wantPanic := "Some really long panic panic panic panic panic panic panic, really it is very long"
	17	numBars := 3
	18	wg.Add(numBars)
	19
	20	for i := 0; i < numBars; i++ {
	21	name := fmt.Sprintf("b#%02d:", i)
	22	bar := p.AddBar(100, mpb.BarID(i), mpb.PrependDecorators(panicDecorator(name, wantPanic)))
	23
	24	go func() {
	25	defer wg.Done()
	26	for i := 0; i < 100; i++ {
	27	time.Sleep(50 * time.Millisecond)
	28	bar.Increment()
	29	}
	30	}()
	31	}
	32
	33	p.Wait()
	34	}
	35
	36	func panicDecorator(name, panicMsg string) decor.Decorator {
	37	d := &decorator{
	38	msg: name,
	39	panicMsg: panicMsg,
	40	}
	41	d.Init()
	42	return d
	43	}
	44
	45	type decorator struct {
	46	decor.WC
	47	msg string
	48	panicMsg string
	49	}
	50
	51	func (d decorator) Decor(st decor.Statistics) string {
	52	if st.ID == 1 && st.Current >= 42 {
	53	panic(d.panicMsg)
	54	}
	55	return d.FormatMsg(d.msg)
	56	}

+57

-0

examples/remove/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	func init() {
	13	rand.Seed(time.Now().UnixNano())
	14	}
	15
	16	func main() {
	17	var wg sync.WaitGroup
	18	p := mpb.New(mpb.WithWaitGroup(&wg))
	19	total := 100
	20	numBars := 3
	21	wg.Add(numBars)
	22
	23	for i := 0; i < numBars; i++ {
	24	name := fmt.Sprintf("Bar#%d:", i)
	25
	26	var bOption mpb.BarOption
	27	if i == 0 {
	28	bOption = mpb.BarRemoveOnComplete()
	29	}
	30
	31	b := p.AddBar(int64(total), mpb.BarID(i),
	32	bOption,
	33	mpb.PrependDecorators(
	34	decor.Name(name),
	35	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	36	),
	37	mpb.AppendDecorators(decor.Percentage()),
	38	)
	39	go func() {
	40	defer wg.Done()
	41	max := 100 * time.Millisecond
	42	for i := 0; i < total; i++ {
	43	start := time.Now()
	44	if b.ID() == 2 && i == 42 {
	45	p.Abort(b, true)
	46	return
	47	}
	48	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	49	// ewma based decorators require work duration measurement
	50	b.IncrBy(1, time.Since(start))
	51	}
	52	}()
	53	}
	54
	55	p.Wait()
	56	}

+54

-0

examples/simple/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	func init() {
	13	rand.Seed(time.Now().UnixNano())
	14	}
	15
	16	func main() {
	17	var wg sync.WaitGroup
	18	p := mpb.New(mpb.WithWaitGroup(&wg))
	19	total, numBars := 100, 3
	20	wg.Add(numBars)
	21
	22	for i := 0; i < numBars; i++ {
	23	name := fmt.Sprintf("Bar#%d:", i)
	24	bar := p.AddBar(int64(total),
	25	mpb.PrependDecorators(
	26	// simple name decorator
	27	decor.Name(name),
	28	// decor.DSyncWidth bit enables column width synchronization
	29	decor.Percentage(decor.WCSyncSpace),
	30	),
	31	mpb.AppendDecorators(
	32	// replace ETA decorator with "done" message, OnComplete event
	33	decor.OnComplete(
	34	// ETA decorator with ewma age of 60
	35	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	36	),
	37	),
	38	)
	39	// simulating some work
	40	go func() {
	41	defer wg.Done()
	42	max := 100 * time.Millisecond
	43	for i := 0; i < total; i++ {
	44	start := time.Now()
	45	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	46	// ewma based decorators require work duration measurement
	47	bar.IncrBy(1, time.Since(start))
	48	}
	49	}()
	50	}
	51	// wait for all bars to complete and flush
	52	p.Wait()
	53	}

+46

-0

examples/singleBar/main.go less more

	0	package main
	1
	2	import (
	3	"math/rand"
	4	"time"
	5
	6	"github.com/vbauerster/mpb"
	7	"github.com/vbauerster/mpb/decor"
	8	)
	9
	10	func main() {
	11	p := mpb.New(
	12	// override default (80) width
	13	mpb.WithWidth(64),
	14	// override default "[=>-]" format
	15	mpb.WithFormat("╢▌▌░╟"),
	16	// override default 120ms refresh rate
	17	mpb.WithRefreshRate(180*time.Millisecond),
	18	)
	19
	20	total := 100
	21	name := "Single Bar:"
	22	// adding a single bar
	23	bar := p.AddBar(int64(total),
	24	mpb.PrependDecorators(
	25	// display our name with one space on the right
	26	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
	27	// replace ETA decorator with "done" message, OnComplete event
	28	decor.OnComplete(
	29	// ETA decorator with ewma age of 60, and width reservation of 4
	30	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
	31	),
	32	),
	33	mpb.AppendDecorators(decor.Percentage()),
	34	)
	35	// simulating some work
	36	max := 100 * time.Millisecond
	37	for i := 0; i < total; i++ {
	38	start := time.Now()
	39	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	40	// ewma based decorators require work duration measurement
	41	bar.IncrBy(1, time.Since(start))
	42	}
	43	// wait for our bar to complete and flush
	44	p.Wait()
	45	}

+55

-0

examples/sort/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	func init() {
	13	rand.Seed(time.Now().UnixNano())
	14	}
	15
	16	func main() {
	17	var wg sync.WaitGroup
	18	p := mpb.New(mpb.WithWaitGroup(&wg))
	19	total := 100
	20	numBars := 3
	21	wg.Add(numBars)
	22
	23	for i := 0; i < numBars; i++ {
	24	var name string
	25	if i != 1 {
	26	name = fmt.Sprintf("Bar#%d:", i)
	27	}
	28	b := p.AddBar(int64(total),
	29	mpb.PrependDecorators(
	30	decor.Name(name, decor.WCSyncWidth),
	31	decor.CountersNoUnit("%d / %d", decor.WCSyncSpace),
	32	),
	33	mpb.AppendDecorators(
	34	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 3}),
	35	),
	36	)
	37	go func() {
	38	defer wg.Done()
	39	max := 100 * time.Millisecond
	40	for i := 0; i < total; i++ {
	41	start := time.Now()
	42	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	43	if i&1 == 1 {
	44	priority := total - int(b.Current())
	45	p.UpdateBarPriority(b, priority)
	46	}
	47	// ewma based decorators require work duration measurement
	48	b.IncrBy(1, time.Since(start))
	49	}
	50	}()
	51	}
	52
	53	p.Wait()
	54	}

+52

-0

examples/stress/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/decor"
	10	)
	11
	12	const (
	13	totalBars = 32
	14	)
	15
	16	func init() {
	17	rand.Seed(time.Now().UnixNano())
	18	}
	19
	20	func main() {
	21	var wg sync.WaitGroup
	22	p := mpb.New(mpb.WithWaitGroup(&wg))
	23	wg.Add(totalBars)
	24
	25	for i := 0; i < totalBars; i++ {
	26	name := fmt.Sprintf("Bar#%02d: ", i)
	27	total := rand.Intn(320) + 10
	28	bar := p.AddBar(int64(total),
	29	mpb.PrependDecorators(
	30	decor.Name(name),
	31	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	32	),
	33	mpb.AppendDecorators(
	34	decor.Percentage(decor.WC{W: 5}),
	35	),
	36	)
	37
	38	go func() {
	39	defer wg.Done()
	40	max := 100 * time.Millisecond
	41	for !bar.Completed() {
	42	start := time.Now()
	43	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	44	// ewma based decorators require work duration measurement
	45	bar.IncrBy(1, time.Since(start))
	46	}
	47	}()
	48	}
	49
	50	p.Wait()
	51	}

+3

-0

export_test.go less more

	0	package mpb
	1
	2	var SyncWidth = syncWidth

+12

-0

go.test.sh less more

	0	#!/usr/bin/env bash
	1
	2	set -e
	3	echo "" > coverage.txt
	4
	5	for d in $(go list ./... \| grep -v vendor); do
	6	go test -race -coverprofile=profile.out -covermode=atomic $d
	7	if [ -f profile.out ]; then
	8	cat profile.out >> coverage.txt
	9	rm profile.out
	10	fi
	11	done

+10

-0

internal/percentage.go less more

	0	package internal
	1
	2	// Percentage is a helper function, to calculate percentage.
	3	func Percentage(total, current, width int64) int64 {
	4	if total <= 0 {
	5	return 0
	6	}
	7	p := float64(width*current) / float64(total)
	8	return int64(Round(p))
	9	}

+74

-0

internal/percentage_test.go less more

	0	package internal
	1
	2	import (
	3	"testing"
	4	)
	5
	6	func TestPercentage(t *testing.T) {
	7	// key is barWidth
	8	testSuite := map[int64]map[string]struct {
	9	total, current, expected int64
	10	}{
	11	100: {
	12	"t,c,e{-1,-1,0}": {-1, -1, 0},
	13	"t,c,e{0,-1,0}": {0, -1, 0},
	14	"t,c,e{0,0,0}": {0, 0, 0},
	15	"t,c,e{0,1,0}": {0, 1, 0},
	16	"t,c,e{100,0,0}": {100, 0, 0},
	17	"t,c,e{100,10,10}": {100, 10, 10},
	18	"t,c,e{100,15,15}": {100, 15, 15},
	19	"t,c,e{100,50,50}": {100, 50, 50},
	20	"t,c,e{100,99,99}": {100, 99, 99},
	21	"t,c,e{100,100,100}": {100, 100, 100},
	22	"t,c,e{100,101,101}": {100, 101, 101},
	23	"t,c,e{100,102,101}": {100, 102, 102},
	24	"t,c,e{120,0,0}": {120, 0, 0},
	25	"t,c,e{120,10,8}": {120, 10, 8},
	26	"t,c,e{120,15,13}": {120, 15, 13},
	27	"t,c,e{120,50,42}": {120, 50, 42},
	28	"t,c,e{120,60,50}": {120, 60, 50},
	29	"t,c,e{120,99,83}": {120, 99, 83},
	30	"t,c,e{120,101,84}": {120, 101, 84},
	31	"t,c,e{120,118,98}": {120, 118, 98},
	32	"t,c,e{120,119,99}": {120, 119, 99},
	33	"t,c,e{120,120,100}": {120, 120, 100},
	34	"t,c,e{120,121,101}": {120, 121, 101},
	35	"t,c,e{120,122,101}": {120, 122, 102},
	36	},
	37	80: {
	38	"t,c,e{-1,-1,0}": {-1, -1, 0},
	39	"t,c,e{0,-1,0}": {0, -1, 0},
	40	"t,c,e{0,0,0}": {0, 0, 0},
	41	"t,c,e{0,1,0}": {0, 1, 0},
	42	"t,c,e{100,0,0}": {100, 0, 0},
	43	"t,c,e{100,10,8}": {100, 10, 8},
	44	"t,c,e{100,15,12}": {100, 15, 12},
	45	"t,c,e{100,50,40}": {100, 50, 40},
	46	"t,c,e{100,99,79}": {100, 99, 79},
	47	"t,c,e{100,100,80}": {100, 100, 80},
	48	"t,c,e{100,101,81}": {100, 101, 81},
	49	"t,c,e{100,102,82}": {100, 102, 82},
	50	"t,c,e{120,0,0}": {120, 0, 0},
	51	"t,c,e{120,10,7}": {120, 10, 7},
	52	"t,c,e{120,15,10}": {120, 15, 10},
	53	"t,c,e{120,50,33}": {120, 50, 33},
	54	"t,c,e{120,60,40}": {120, 60, 40},
	55	"t,c,e{120,99,66}": {120, 99, 66},
	56	"t,c,e{120,101,67}": {120, 101, 67},
	57	"t,c,e{120,118,79}": {120, 118, 79},
	58	"t,c,e{120,119,79}": {120, 119, 79},
	59	"t,c,e{120,120,80}": {120, 120, 80},
	60	"t,c,e{120,121,81}": {120, 121, 81},
	61	"t,c,e{120,122,81}": {120, 122, 81},
	62	},
	63	}
	64
	65	for width, cases := range testSuite {
	66	for name, tc := range cases {
	67	got := Percentage(tc.total, tc.current, width)
	68	if got != tc.expected {
	69	t.Errorf("width %d; %s: Expected: %d, got: %d\n", width, name, tc.expected, got)
	70	}
	71	}
	72	}
	73	}

+49

-0

internal/round.go less more

	0	package internal
	1
	2	import "math"
	3
	4	const (
	5	uvone = 0x3FF0000000000000
	6	mask = 0x7FF
	7	shift = 64 - 11 - 1
	8	bias = 1023
	9	signMask = 1 << 63
	10	fracMask = 1<<shift - 1
	11	)
	12
	13	// Round returns the nearest integer, rounding half away from zero.
	14	//
	15	// Special cases are:
	16	// Round(±0) = ±0
	17	// Round(±Inf) = ±Inf
	18	// Round(NaN) = NaN
	19	func Round(x float64) float64 {
	20	// Round is a faster implementation of:
	21	//
	22	// func Round(x float64) float64 {
	23	// t := Trunc(x)
	24	// if Abs(x-t) >= 0.5 {
	25	// return t + Copysign(1, x)
	26	// }
	27	// return t
	28	// }
	29	bits := math.Float64bits(x)
	30	e := uint(bits>>shift) & mask
	31	if e < bias {
	32	// Round abs(x) < 1 including denormals.
	33	bits &= signMask // +-0
	34	if e == bias-1 {
	35	bits \|= uvone // +-1
	36	}
	37	} else if e < bias+shift {
	38	// Round any abs(x) >= 1 containing a fractional component [0,1).
	39	//
	40	// Numbers with larger exponents are returned unchanged since they
	41	// must be either an integer, infinity, or NaN.
	42	const half = 1 << (shift - 1)
	43	e -= bias
	44	bits += half >> e
	45	bits &^= fracMask >> e
	46	}
	47	return math.Float64frombits(bits)
	48	}

+95

-0

options.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4	"sync"
	5	"time"
	6	"unicode/utf8"
	7
	8	"github.com/vbauerster/mpb/cwriter"
	9	)
	10
	11	// ProgressOption is a function option which changes the default behavior of
	12	// progress pool, if passed to mpb.New(...ProgressOption)
	13	type ProgressOption func(*pState)
	14
	15	// WithWaitGroup provides means to have a single joint point.
	16	// If *sync.WaitGroup is provided, you can safely call just p.Wait()
	17	// without calling Wait() on provided *sync.WaitGroup.
	18	// Makes sense when there are more than one bar to render.
	19	func WithWaitGroup(wg *sync.WaitGroup) ProgressOption {
	20	return func(s *pState) {
	21	s.uwg = wg
	22	}
	23	}
	24
	25	// WithWidth overrides default width 80
	26	func WithWidth(w int) ProgressOption {
	27	return func(s *pState) {
	28	if w >= 0 {
	29	s.width = w
	30	}
	31	}
	32	}
	33
	34	// WithFormat overrides default bar format "[=>-]"
	35	func WithFormat(format string) ProgressOption {
	36	return func(s *pState) {
	37	if utf8.RuneCountInString(format) == formatLen {
	38	s.format = format
	39	}
	40	}
	41	}
	42
	43	// WithRefreshRate overrides default 120ms refresh rate
	44	func WithRefreshRate(d time.Duration) ProgressOption {
	45	return func(s *pState) {
	46	if d < 10*time.Millisecond {
	47	return
	48	}
	49	s.rr = d
	50	}
	51	}
	52
	53	// WithManualRefresh disables internal auto refresh time.Ticker.
	54	// Refresh will occur upon receive value from provided ch.
	55	func WithManualRefresh(ch <-chan time.Time) ProgressOption {
	56	return func(s *pState) {
	57	s.manualRefreshCh = ch
	58	}
	59	}
	60
	61	// WithCancel provide your cancel channel,
	62	// which you plan to close at some point.
	63	func WithCancel(ch <-chan struct{}) ProgressOption {
	64	return func(s *pState) {
	65	s.cancel = ch
	66	}
	67	}
	68
	69	// WithShutdownNotifier provided chanel will be closed, after all bars have been rendered.
	70	func WithShutdownNotifier(ch chan struct{}) ProgressOption {
	71	return func(s *pState) {
	72	s.shutdownNotifier = ch
	73	}
	74	}
	75
	76	// WithOutput overrides default output os.Stdout
	77	func WithOutput(w io.Writer) ProgressOption {
	78	return func(s *pState) {
	79	if w == nil {
	80	return
	81	}
	82	s.cw = cwriter.New(w)
	83	}
	84	}
	85
	86	// WithDebugOutput sets debug output.
	87	func WithDebugOutput(w io.Writer) ProgressOption {
	88	return func(s *pState) {
	89	if w == nil {
	90	return
	91	}
	92	s.debugOut = w
	93	}
	94	}

+15

-0

options_go1.7.go less more

	0	//+build go1.7
	1
	2	package mpb
	3
	4	import "context"
	5
	6	// WithContext provided context will be used for cancellation purposes
	7	func WithContext(ctx context.Context) ProgressOption {
	8	return func(s *pState) {
	9	if ctx == nil {
	10	panic("ctx must not be nil")
	11	}
	12	s.cancel = ctx.Done()
	13	}
	14	}

+40

-0

priority_queue.go less more

	0	package mpb
	1
	2	import "container/heap"
	3
	4	// A priorityQueue implements heap.Interface
	5	type priorityQueue []*Bar
	6
	7	func (pq priorityQueue) Len() int { return len(pq) }
	8
	9	func (pq priorityQueue) Less(i, j int) bool {
	10	return pq[i].priority < pq[j].priority
	11	}
	12
	13	func (pq priorityQueue) Swap(i, j int) {
	14	pq[i], pq[j] = pq[j], pq[i]
	15	pq[i].index = i
	16	pq[j].index = j
	17	}
	18
	19	func (pq *priorityQueue) Push(x interface{}) {
	20	n := len(*pq)
	21	bar := x.(*Bar)
	22	bar.index = n
	23	pq = append(pq, bar)
	24	}
	25
	26	func (pq *priorityQueue) Pop() interface{} {
	27	old := *pq
	28	n := len(old)
	29	bar := old[n-1]
	30	bar.index = -1 // for safety
	31	*pq = old[0 : n-1]
	32	return bar
	33	}
	34
	35	// update modifies the priority of a Bar in the queue.
	36	func (pq priorityQueue) update(bar Bar, priority int) {
	37	bar.priority = priority
	38	heap.Fix(pq, bar.index)
	39	}

+251

-0

progress.go less more

	0	package mpb
	1
	2	import (
	3	"container/heap"
	4	"fmt"
	5	"io"
	6	"io/ioutil"
	7	"os"
	8	"sync"
	9	"time"
	10
	11	"github.com/vbauerster/mpb/cwriter"
	12	)
	13
	14	const (
	15	// default RefreshRate
	16	prr = 120 * time.Millisecond
	17	// default width
	18	pwidth = 80
	19	// default format
	20	pformat = "[=>-]"
	21	)
	22
	23	// Progress represents the container that renders Progress bars
	24	type Progress struct {
	25	wg *sync.WaitGroup
	26	uwg *sync.WaitGroup
	27	operateState chan func(*pState)
	28	done chan struct{}
	29	}
	30
	31	type pState struct {
	32	bHeap *priorityQueue
	33	shutdownPending []*Bar
	34	heapUpdated bool
	35	zeroWait bool
	36	idCounter int
	37	width int
	38	format string
	39	rr time.Duration
	40	cw *cwriter.Writer
	41	pMatrix map[int][]chan int
	42	aMatrix map[int][]chan int
	43
	44	// following are provided by user
	45	uwg *sync.WaitGroup
	46	manualRefreshCh <-chan time.Time
	47	cancel <-chan struct{}
	48	shutdownNotifier chan struct{}
	49	waitBars map[Bar]Bar
	50	debugOut io.Writer
	51	}
	52
	53	// New creates new Progress instance, which orchestrates bars rendering process.
	54	// Accepts mpb.ProgressOption funcs for customization.
	55	func New(options ...ProgressOption) *Progress {
	56	pq := make(priorityQueue, 0)
	57	heap.Init(&pq)
	58	s := &pState{
	59	bHeap: &pq,
	60	width: pwidth,
	61	format: pformat,
	62	cw: cwriter.New(os.Stdout),
	63	rr: prr,
	64	waitBars: make(map[Bar]Bar),
	65	debugOut: ioutil.Discard,
	66	}
	67
	68	for _, opt := range options {
	69	if opt != nil {
	70	opt(s)
	71	}
	72	}
	73
	74	p := &Progress{
	75	uwg: s.uwg,
	76	wg: new(sync.WaitGroup),
	77	operateState: make(chan func(*pState)),
	78	done: make(chan struct{}),
	79	}
	80	go p.serve(s)
	81	return p
	82	}
	83
	84	// AddBar creates a new progress bar and adds to the container.
	85	func (p Progress) AddBar(total int64, options ...BarOption) Bar {
	86	p.wg.Add(1)
	87	result := make(chan *Bar)
	88	select {
	89	case p.operateState <- func(s *pState) {
	90	options = append(options, barWidth(s.width), barFormat(s.format))
	91	b := newBar(p.wg, s.idCounter, total, s.cancel, options...)
	92	if b.runningBar != nil {
	93	s.waitBars[b.runningBar] = b
	94	} else {
	95	heap.Push(s.bHeap, b)
	96	s.heapUpdated = true
	97	}
	98	s.idCounter++
	99	result <- b
	100	}:
	101	return <-result
	102	case <-p.done:
	103	p.wg.Done()
	104	return nil
	105	}
	106	}
	107
	108	// Abort is only effective while bar progress is running,
	109	// it means remove bar now without waiting for its completion.
	110	// If bar is already completed, there is nothing to abort.
	111	// If you need to remove bar after completion, use BarRemoveOnComplete BarOption.
	112	func (p Progress) Abort(b Bar, remove bool) {
	113	select {
	114	case p.operateState <- func(s *pState) {
	115	if b.index < 0 {
	116	return
	117	}
	118	if remove {
	119	s.heapUpdated = heap.Remove(s.bHeap, b.index) != nil
	120	}
	121	s.shutdownPending = append(s.shutdownPending, b)
	122	}:
	123	case <-p.done:
	124	}
	125	}
	126
	127	// UpdateBarPriority provides a way to change bar's order position.
	128	// Zero is highest priority, i.e. bar will be on top.
	129	func (p Progress) UpdateBarPriority(b Bar, priority int) {
	130	select {
	131	case p.operateState <- func(s *pState) { s.bHeap.update(b, priority) }:
	132	case <-p.done:
	133	}
	134	}
	135
	136	// BarCount returns bars count
	137	func (p *Progress) BarCount() int {
	138	result := make(chan int, 1)
	139	select {
	140	case p.operateState <- func(s *pState) { result <- s.bHeap.Len() }:
	141	return <-result
	142	case <-p.done:
	143	return 0
	144	}
	145	}
	146
	147	// Wait first waits for user provided *sync.WaitGroup, if any,
	148	// then waits far all bars to complete and finally shutdowns master goroutine.
	149	// After this method has been called, there is no way to reuse *Progress instance.
	150	func (p *Progress) Wait() {
	151	if p.uwg != nil {
	152	p.uwg.Wait()
	153	}
	154
	155	p.wg.Wait()
	156
	157	select {
	158	case p.operateState <- func(s *pState) { s.zeroWait = true }:
	159	<-p.done
	160	case <-p.done:
	161	}
	162	}
	163
	164	func (s *pState) updateSyncMatrix() {
	165	s.pMatrix = make(map[int][]chan int)
	166	s.aMatrix = make(map[int][]chan int)
	167	for i := 0; i < s.bHeap.Len(); i++ {
	168	bar := (*s.bHeap)[i]
	169	table := bar.wSyncTable()
	170	pRow, aRow := table[0], table[1]
	171
	172	for i, ch := range pRow {
	173	s.pMatrix[i] = append(s.pMatrix[i], ch)
	174	}
	175
	176	for i, ch := range aRow {
	177	s.aMatrix[i] = append(s.aMatrix[i], ch)
	178	}
	179	}
	180	}
	181
	182	func (s *pState) render(tw int) {
	183	if s.heapUpdated {
	184	s.updateSyncMatrix()
	185	s.heapUpdated = false
	186	}
	187	syncWidth(s.pMatrix)
	188	syncWidth(s.aMatrix)
	189
	190	for i := 0; i < s.bHeap.Len(); i++ {
	191	bar := (*s.bHeap)[i]
	192	go bar.render(s.debugOut, tw)
	193	}
	194
	195	if err := s.flush(s.bHeap.Len()); err != nil {
	196	fmt.Fprintf(s.debugOut, "%s %s %v\n", "[mpb]", time.Now(), err)
	197	}
	198	}
	199
	200	func (s *pState) flush(lineCount int) error {
	201	for s.bHeap.Len() > 0 {
	202	bar := heap.Pop(s.bHeap).(*Bar)
	203	frameReader := <-bar.frameReaderCh
	204	defer func() {
	205	if frameReader.toShutdown {
	206	// shutdown at next flush, in other words decrement underlying WaitGroup
	207	// only after the bar with completed state has been flushed.
	208	// this ensures no bar ends up with less than 100% rendered.
	209	s.shutdownPending = append(s.shutdownPending, bar)
	210	if replacementBar, ok := s.waitBars[bar]; ok {
	211	heap.Push(s.bHeap, replacementBar)
	212	s.heapUpdated = true
	213	delete(s.waitBars, bar)
	214	}
	215	if frameReader.removeOnComplete {
	216	s.heapUpdated = true
	217	return
	218	}
	219	}
	220	heap.Push(s.bHeap, bar)
	221	}()
	222	s.cw.ReadFrom(frameReader)
	223	lineCount += frameReader.extendedLines
	224	}
	225
	226	for i := len(s.shutdownPending) - 1; i >= 0; i-- {
	227	close(s.shutdownPending[i].shutdown)
	228	s.shutdownPending = s.shutdownPending[:i]
	229	}
	230
	231	return s.cw.Flush(lineCount)
	232	}
	233
	234	func syncWidth(matrix map[int][]chan int) {
	235	for _, column := range matrix {
	236	column := column
	237	go func() {
	238	var maxWidth int
	239	for _, ch := range column {
	240	w := <-ch
	241	if w > maxWidth {
	242	maxWidth = w
	243	}
	244	}
	245	for _, ch := range column {
	246	ch <- maxWidth
	247	}
	248	}()
	249	}
	250	}

+50

-0

progress_go1.7_test.go less more

	0	//+build go1.7
	1
	2	package mpb_test
	3
	4	import (
	5	"context"
	6	"io/ioutil"
	7	"testing"
	8	"time"
	9
	10	"github.com/vbauerster/mpb"
	11	)
	12
	13	func TestWithContext(t *testing.T) {
	14	ctx, cancel := context.WithCancel(context.Background())
	15	shutdown := make(chan struct{})
	16	p := mpb.New(
	17	mpb.WithOutput(ioutil.Discard),
	18	mpb.WithContext(ctx),
	19	mpb.WithShutdownNotifier(shutdown),
	20	)
	21
	22	total := 1000
	23	numBars := 3
	24	bars := make([]*mpb.Bar, 0, numBars)
	25	for i := 0; i < numBars; i++ {
	26	bar := p.AddBar(int64(total))
	27	bars = append(bars, bar)
	28	go func() {
	29	for !bar.Completed() {
	30	time.Sleep(randomDuration(40 * time.Millisecond))
	31	bar.Increment()
	32	}
	33	}()
	34	}
	35
	36	time.AfterFunc(100*time.Millisecond, cancel)
	37
	38	p.Wait()
	39	for _, bar := range bars {
	40	if bar.Current() >= int64(total) {
	41	t.Errorf("bar %d: total = %d, current = %d\n", bar.ID(), total, bar.Current())
	42	}
	43	}
	44	select {
	45	case <-shutdown:
	46	case <-time.After(100 * time.Millisecond):
	47	t.Error("Progress didn't stop")
	48	}
	49	}

+70

-0

progress_posix.go less more

	0	// +build !windows
	1
	2	package mpb
	3
	4	import (
	5	"os"
	6	"os/signal"
	7	"syscall"
	8	"time"
	9	)
	10
	11	func (p Progress) serve(s pState) {
	12
	13	var ticker *time.Ticker
	14	var refreshCh <-chan time.Time
	15	var winch chan os.Signal
	16	var resumeTimer *time.Timer
	17	var resumeEvent <-chan time.Time
	18	winchIdleDur := s.rr * 2
	19
	20	if s.manualRefreshCh == nil {
	21	ticker = time.NewTicker(s.rr)
	22	refreshCh = ticker.C
	23	winch = make(chan os.Signal, 2)
	24	signal.Notify(winch, syscall.SIGWINCH)
	25	} else {
	26	refreshCh = s.manualRefreshCh
	27	}
	28
	29	for {
	30	select {
	31	case op := <-p.operateState:
	32	op(s)
	33	case <-refreshCh:
	34	if s.zeroWait {
	35	if s.manualRefreshCh == nil {
	36	signal.Stop(winch)
	37	ticker.Stop()
	38	}
	39	if s.shutdownNotifier != nil {
	40	close(s.shutdownNotifier)
	41	}
	42	close(p.done)
	43	return
	44	}
	45	tw, err := s.cw.GetWidth()
	46	if err != nil {
	47	tw = s.width
	48	}
	49	s.render(tw)
	50	case <-winch:
	51	tw, err := s.cw.GetWidth()
	52	if err != nil {
	53	tw = s.width
	54	}
	55	s.render(tw - tw/8)
	56	if resumeTimer != nil && resumeTimer.Reset(winchIdleDur) {
	57	break
	58	}
	59	ticker.Stop()
	60	resumeTimer = time.NewTimer(winchIdleDur)
	61	resumeEvent = resumeTimer.C
	62	case <-resumeEvent:
	63	ticker = time.NewTicker(s.rr)
	64	refreshCh = ticker.C
	65	resumeEvent = nil
	66	resumeTimer = nil
	67	}
	68	}
	69	}

+149

-0

progress_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"bytes"
	4	"fmt"
	5	"io/ioutil"
	6	"math/rand"
	7	"sync"
	8	"testing"
	9	"time"
	10
	11	. "github.com/vbauerster/mpb"
	12	"github.com/vbauerster/mpb/cwriter"
	13	)
	14
	15	var (
	16	cursorUp = fmt.Sprintf("%c[%dA", cwriter.ESC, 1)
	17	clearLine = fmt.Sprintf("%c[2K\r", cwriter.ESC)
	18	clearCursorAndLine = cursorUp + clearLine
	19	)
	20
	21	func init() {
	22	rand.Seed(time.Now().UnixNano())
	23	}
	24
	25	func TestBarCount(t *testing.T) {
	26	p := New(WithOutput(ioutil.Discard))
	27
	28	var wg sync.WaitGroup
	29	wg.Add(1)
	30	b := p.AddBar(100)
	31	go func() {
	32	for i := 0; i < 100; i++ {
	33	if i == 33 {
	34	wg.Done()
	35	}
	36	b.Increment()
	37	time.Sleep(randomDuration(100 * time.Millisecond))
	38	}
	39	}()
	40
	41	wg.Wait()
	42	count := p.BarCount()
	43	if count != 1 {
	44	t.Errorf("BarCount want: %q, got: %q\n", 1, count)
	45	}
	46
	47	p.Abort(b, true)
	48	p.Wait()
	49	}
	50
	51	func TestBarAbort(t *testing.T) {
	52	p := New(WithOutput(ioutil.Discard))
	53
	54	var wg sync.WaitGroup
	55	wg.Add(1)
	56	bars := make([]*Bar, 3)
	57	for i := 0; i < 3; i++ {
	58	b := p.AddBar(100)
	59	bars[i] = b
	60	go func(n int) {
	61	for i := 0; i < 100; i++ {
	62	if n == 0 && i == 33 {
	63	p.Abort(b, true)
	64	wg.Done()
	65	}
	66	b.Increment()
	67	time.Sleep(randomDuration(100 * time.Millisecond))
	68	}
	69	}(i)
	70	}
	71
	72	wg.Wait()
	73	count := p.BarCount()
	74	if count != 2 {
	75	t.Errorf("BarCount want: %q, got: %q\n", 2, count)
	76	}
	77	p.Abort(bars[1], true)
	78	p.Abort(bars[2], true)
	79	p.Wait()
	80	}
	81
	82	func TestWithCancel(t *testing.T) {
	83	cancel := make(chan struct{})
	84	shutdown := make(chan struct{})
	85	p := New(
	86	WithOutput(ioutil.Discard),
	87	WithCancel(cancel),
	88	WithShutdownNotifier(shutdown),
	89	)
	90
	91	for i := 0; i < 2; i++ {
	92	bar := p.AddBar(int64(1000), BarID(i))
	93	go func() {
	94	for !bar.Completed() {
	95	time.Sleep(randomDuration(100 * time.Millisecond))
	96	bar.Increment()
	97	}
	98	}()
	99	}
	100
	101	time.AfterFunc(100*time.Millisecond, func() {
	102	close(cancel)
	103	})
	104
	105	p.Wait()
	106
	107	select {
	108	case <-shutdown:
	109	case <-time.After(200 * time.Millisecond):
	110	t.FailNow()
	111	}
	112	}
	113
	114	func TestWithFormat(t *testing.T) {
	115	var buf bytes.Buffer
	116	customFormat := "╢▌▌░╟"
	117	p := New(WithOutput(&buf), WithFormat(customFormat))
	118	bar := p.AddBar(100, BarTrim())
	119
	120	for i := 0; i < 100; i++ {
	121	if i == 33 {
	122	p.Abort(bar, true)
	123	break
	124	}
	125	time.Sleep(randomDuration(100 * time.Millisecond))
	126	bar.Increment()
	127	}
	128
	129	p.Wait()
	130
	131	lastLine := getLastLine(buf.Bytes())
	132
	133	for _, r := range customFormat {
	134	if !bytes.ContainsRune(lastLine, r) {
	135	t.Errorf("Rune %#U not found in bar\n", r)
	136	}
	137	}
	138	}
	139
	140	func getLastLine(bb []byte) []byte {
	141	split := bytes.Split(bb, []byte("\n"))
	142	lastLine := split[len(split)-2]
	143	return lastLine[len(clearCursorAndLine):]
	144	}
	145
	146	func randomDuration(max time.Duration) time.Duration {
	147	return time.Duration(rand.Intn(10)+1) * max / 10
	148	}

+43

-0

progress_windows.go less more

	0	// +build windows
	1
	2	package mpb
	3
	4	import (
	5	"time"
	6	)
	7
	8	func (p Progress) serve(s pState) {
	9
	10	var ticker *time.Ticker
	11	var refreshCh <-chan time.Time
	12
	13	if s.manualRefreshCh == nil {
	14	ticker = time.NewTicker(s.rr)
	15	refreshCh = ticker.C
	16	} else {
	17	refreshCh = s.manualRefreshCh
	18	}
	19
	20	for {
	21	select {
	22	case op := <-p.operateState:
	23	op(s)
	24	case <-refreshCh:
	25	if s.zeroWait {
	26	if s.manualRefreshCh == nil {
	27	ticker.Stop()
	28	}
	29	if s.shutdownNotifier != nil {
	30	close(s.shutdownNotifier)
	31	}
	32	close(p.done)
	33	return
	34	}
	35	tw, err := s.cw.GetWidth()
	36	if err != nil {
	37	tw = s.width
	38	}
	39	s.render(tw)
	40	}
	41	}
	42	}

+22

-0

proxyreader.go less more

	0	package mpb
	1
	2	import (
	3	"io"
	4	"time"
	5	)
	6
	7	// proxyReader is io.Reader wrapper, for proxy read bytes
	8	type proxyReader struct {
	9	io.ReadCloser
	10	bar *Bar
	11	iT time.Time
	12	}
	13
	14	func (pr *proxyReader) Read(p []byte) (n int, err error) {
	15	n, err = pr.ReadCloser.Read(p)
	16	if n > 0 {
	17	pr.bar.IncrBy(n, time.Since(pr.iT))
	18	pr.iT = time.Now()
	19	}
	20	return
	21	}

+45

-0

proxyreader_test.go less more

	0	package mpb_test
	1
	2	import (
	3	"bytes"
	4	"io"
	5	"io/ioutil"
	6	"strings"
	7	"testing"
	8
	9	"github.com/vbauerster/mpb"
	10	)
	11
	12	const content = `Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
	13	eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
	14	veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
	15	commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit
	16	esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
	17	cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
	18	est laborum.`
	19
	20	func TestProxyReader(t *testing.T) {
	21	var buf bytes.Buffer
	22	p := mpb.New(mpb.WithOutput(&buf))
	23
	24	reader := strings.NewReader(content)
	25
	26	total := len(content)
	27	bar := p.AddBar(100, mpb.BarTrim())
	28	preader := bar.ProxyReader(reader)
	29
	30	if _, ok := preader.(io.Closer); !ok {
	31	t.Error("type assertion to io.Closer is not ok")
	32	}
	33
	34	written, err := io.Copy(ioutil.Discard, preader)
	35	if err != nil {
	36	t.Errorf("Error copying from reader: %+v\n", err)
	37	}
	38
	39	p.Wait()
	40
	41	if written != int64(total) {
	42	t.Errorf("Expected written: %d, got: %d\n", total, written)
	43	}
	44	}