26191557037

Committed 20 May 2026 09:39PM UTC coverage: 99.636% (-0.4%) from 100.0%

Build # 26191557037

Build Type

Pull #406

github

Committed by

jedib0t

Commit Message

progress: KeepTrackersTogether option; restore pre-v6.7.8 layout as default

Makes v6.7.8's merged-tracker-list behavior opt-in via
StyleOptions.KeepTrackersTogether. Default restores the pre-v6.7.8
layout: done trackers exit the rewindable region on completion, logs
sit between newly-done and active. SortByIndex / SortByIndexDsc need
the option to reorder trackers after they complete.

Pull Request Pull Request #406: progress: fix speed decay on done trackers and log overwrite; fixes #405

Coverage Stats

89 of 95 new or added lines in 2 files covered. (93.68%)

12 existing lines in 1 file now uncovered.

4931 of 4949 relevant lines covered (99.64%)

1.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.72

/progress/render.go

package progress

import (
        "fmt"
        "math"
        "strings"
        "time"

        "github.com/jedib0t/go-pretty/v6/text"
)

// Render renders the Progress tracker and handles all existing trackers and
// those that are added dynamically while render is in progress.
func (p *Progress) Render() {
        if p.beginRender() {
                p.initForRender()

                lastRenderLength := 0
                ticker := time.NewTicker(p.updateFrequency)
                defer ticker.Stop()
                for {
                        select {
                        case <-ticker.C:
                                lastRenderLength = p.renderTrackers(lastRenderLength)
                        case <-p.renderContext.Done():
                                // always render the current state before finishing render in
                                // case it hasn't been shown yet
                                p.renderTrackers(lastRenderLength)
                                p.endRender()
                                return
                        }
                }
        }
}

func (p *Progress) beginRender() bool {
        p.renderInProgressMutex.Lock()
        defer p.renderInProgressMutex.Unlock()

        if p.renderInProgress {
                return false
        }
        p.renderInProgress = true
        return true
}

func (p *Progress) collectActiveTrackers() ([]*Tracker, int64, time.Duration) {
        var allTrackers []*Tracker
        var activeTrackersProgress int64
        var maxETA time.Duration

        p.trackersDoneMutex.RLock()
        lengthDone := len(p.trackersDone)
        p.trackersDoneMutex.RUnlock()

        p.trackersActiveMutex.RLock()
        allTrackers = make([]*Tracker, 0, len(p.trackersActive)+lengthDone)
        for _, tracker := range p.trackersActive {
                if !tracker.IsDone() || !tracker.RemoveOnCompletion {
                        allTrackers = append(allTrackers, tracker)
                        if !tracker.IsDone() {
                                activeTrackersProgress += int64(tracker.PercentDone())
                                if eta := tracker.ETA(); eta > maxETA {
                                        maxETA = eta
                                }
                        }
                }
        }
        p.trackersActiveMutex.RUnlock()

        return allTrackers, activeTrackersProgress, maxETA
}

func (p *Progress) collectDoneTrackers(allTrackers *[]*Tracker) {
        p.trackersDoneMutex.RLock()
        for _, tracker := range p.trackersDone {
                if !tracker.RemoveOnCompletion {
                        *allTrackers = append(*allTrackers, tracker)
                }
        }
        p.trackersDoneMutex.RUnlock()
}

func (p *Progress) consumeQueuedTrackers() {
        p.trackersInQueueMutex.Lock()
        queueLen := len(p.trackersInQueue)
        if queueLen == 0 {
                p.trackersInQueueMutex.Unlock()
                return
        }
        // copy the slice to avoid race condition - another goroutine may append
        // to p.trackersInQueue while we're appending to p.trackersActive
        queued := make([]*Tracker, len(p.trackersInQueue))
        copy(queued, p.trackersInQueue)
        p.trackersInQueue = p.trackersInQueue[:0] // reuse slice capacity
        p.trackersInQueueMutex.Unlock()

        p.trackersActiveMutex.Lock()
        p.trackersActive = append(p.trackersActive, queued...)
        p.trackersActiveMutex.Unlock()
}

func (p *Progress) endRender() {
        p.renderInProgressMutex.Lock()
        defer p.renderInProgressMutex.Unlock()

        p.renderInProgress = false
}

// extractDoneAndActiveTrackers walks p.trackersActive and partitions it into
// (stillActive, newlyDone). Used by the default scrollback render path; mirrors
// the pre-v6.7.8 behavior where done trackers exit the rewindable region on
// completion.
func (p *Progress) extractDoneAndActiveTrackers() ([]*Tracker, []*Tracker) {
        p.consumeQueuedTrackers()

        var trackersActive, trackersNewlyDone []*Tracker
        var activeTrackersProgress int64
        var maxETA time.Duration

        p.trackersDoneMutex.RLock()
        lengthDone := len(p.trackersDone)
        p.trackersDoneMutex.RUnlock()

        p.trackersActiveMutex.RLock()
        trackersActive = make([]*Tracker, 0, len(p.trackersActive))
        trackersNewlyDone = make([]*Tracker, 0, len(p.trackersActive)/4)
        for _, tracker := range p.trackersActive {
                if !tracker.IsDone() {
                        trackersActive = append(trackersActive, tracker)
                        activeTrackersProgress += int64(tracker.PercentDone())
                        if eta := tracker.ETA(); eta > maxETA {
                                maxETA = eta
                        }
                } else if !tracker.RemoveOnCompletion {
                        trackersNewlyDone = append(trackersNewlyDone, tracker)
                }
        }
        p.trackersActiveMutex.RUnlock()
        p.sortBy.Sort(trackersNewlyDone)
        p.sortBy.Sort(trackersActive)

        p.overallTracker.value = int64(lengthDone+len(trackersNewlyDone)) * 100
        p.overallTracker.value += activeTrackersProgress
        p.overallTracker.minETA = maxETA
        if len(trackersActive) == 0 {
                p.overallTracker.MarkAsDone()
        }

        return trackersActive, trackersNewlyDone
}

// extractAllTrackersInOrder extracts all trackers (both active and done) and
// sorts them together when SortByIndex is used. This allows maintaining a fixed
// order regardless of completion status. Used by the KeepTrackersTogether path.
func (p *Progress) extractAllTrackersInOrder() []*Tracker {
        // move trackers waiting in queue to the active list
        p.consumeQueuedTrackers()

        allTrackers, activeTrackersProgress, maxETA := p.collectActiveTrackers()
        p.collectDoneTrackers(&allTrackers)

        // Sort by Index (ascending or descending)
        if p.sortBy == SortByIndex || p.sortBy == SortByIndexDsc {
                p.sortBy.Sort(allTrackers)
        }

        p.updateOverallTrackerProgress(allTrackers, activeTrackersProgress, maxETA)

        return allTrackers
}

func (p *Progress) generateTrackerStr(t *Tracker, maxLen int, hint renderHint) string {
        value, total := t.valueAndTotal()
        if !hint.isOverallTracker && t.IsStarted() && (total == 0 || value > total) {
                return p.generateTrackerStrIndeterminate(maxLen)
        }
        return p.generateTrackerStrDeterminate(value, total, maxLen)
}

// generateTrackerStrDeterminate generates the tracker string for the case where
// the Total value is known, and the progress percentage can be calculated.
func (p *Progress) generateTrackerStrDeterminate(value int64, total int64, maxLen int) string {
        if p.style.Renderer.TrackerDeterminate != nil {
                return p.style.Renderer.TrackerDeterminate(value, total, maxLen)
        }

        pFinishedDots, pFinishedDotsFraction := 0.0, 0.0
        pDotValue := float64(total) / float64(maxLen)
        if pDotValue > 0 {
                pFinishedDots = float64(value) / pDotValue
                pFinishedDotsFraction = pFinishedDots - float64(int(pFinishedDots))
        }
        pFinishedLen := int(math.Floor(pFinishedDots))

        var pFinished, pInProgress, pUnfinished string
        if pFinishedLen > 0 {
                pFinished = strings.Repeat(p.style.Chars.Finished, pFinishedLen)
        }
        pInProgress = p.style.Chars.Unfinished
        if pFinishedDotsFraction >= 0.75 {
                pInProgress = p.style.Chars.Finished75
        } else if pFinishedDotsFraction >= 0.50 {
                pInProgress = p.style.Chars.Finished50
        } else if pFinishedDotsFraction >= 0.25 {
                pInProgress = p.style.Chars.Finished25
        } else if pFinishedDotsFraction == 0 {
                pInProgress = ""
        }

        // Use strings.Builder to avoid temporary string allocation
        var combined strings.Builder
        combined.Grow(len(pFinished) + len(pInProgress))
        combined.WriteString(pFinished)
        combined.WriteString(pInProgress)
        pFinishedStrLen := text.StringWidthWithoutEscSequences(combined.String())
        if pFinishedStrLen < maxLen {
                pUnfinished = strings.Repeat(p.style.Chars.Unfinished, maxLen-pFinishedStrLen)
        }

        return p.style.Colors.Tracker.Sprintf("%s%s%s%s%s",
                p.style.Chars.BoxLeft, pFinished, pInProgress, pUnfinished, p.style.Chars.BoxRight,
        )
}

// generateTrackerStrIndeterminate generates the tracker string for the case where
// the Total value is unknown, and the progress percentage cannot be calculated.
func (p *Progress) generateTrackerStrIndeterminate(maxLen int) string {
        if p.style.Renderer.TrackerIndeterminate != nil {
                return p.style.Renderer.TrackerIndeterminate(maxLen)
        }

        indicator := p.style.Chars.Indeterminate(maxLen)

        pUnfinished := ""
        if indicator.Position > 0 {
                pUnfinished += strings.Repeat(p.style.Chars.Unfinished, indicator.Position)
        }
        pUnfinished += indicator.Text
        if text.StringWidthWithoutEscSequences(pUnfinished) < maxLen {
                pUnfinished += strings.Repeat(p.style.Chars.Unfinished, maxLen-text.StringWidthWithoutEscSequences(pUnfinished))
        }

        return p.style.Colors.Tracker.Sprintf("%s%s%s",
                p.style.Chars.BoxLeft, pUnfinished, p.style.Chars.BoxRight,
        )
}

func (p *Progress) moveCursorToTheTop(out *strings.Builder) {
        // Count trackers that occupy the rewindable region. In the default
        // scrollback mode, that's just active trackers; with KeepTrackersTogether,
        // done trackers are also re-rendered each tick.
        var numTrackersToRender int

        p.trackersActiveMutex.RLock()
        for _, tracker := range p.trackersActive {
                if !tracker.RemoveOnCompletion {
                        numTrackersToRender++
                }
        }
        p.trackersActiveMutex.RUnlock()

        if p.style.Options.KeepTrackersTogether {
                p.trackersDoneMutex.RLock()
                for _, tracker := range p.trackersDone {
                        if !tracker.RemoveOnCompletion {
                                numTrackersToRender++
                        }
                }
                p.trackersDoneMutex.RUnlock()
        }

        numLinesToMoveUp := numTrackersToRender
        if p.style.Visibility.TrackerOverall && p.overallTracker != nil && !p.overallTracker.IsDone() {
                numLinesToMoveUp++
        }
        if p.style.Visibility.Pinned {
                numLinesToMoveUp += p.pinnedMessageNumLines
        }
        for numLinesToMoveUp > 0 {
                out.WriteString(text.CursorUp.Sprint())
                out.WriteString(text.EraseLine.Sprint())
                numLinesToMoveUp--
        }
}

func (p *Progress) renderPinnedMessages(out *strings.Builder, hint renderHint) {
        p.pinnedMessageMutex.RLock()
        defer p.pinnedMessageMutex.RUnlock()

        numLines := len(p.pinnedMessages)
        for _, msg := range p.pinnedMessages {
                msg = strings.TrimSpace(msg)
                msg = p.style.Colors.Pinned.Sprint(msg)
                if hint.terminalWidth > 0 {
                        msg = text.Trim(msg, hint.terminalWidth)
                }
                out.WriteString(msg)
                out.WriteRune('\n')

                numLines += strings.Count(msg, "\n")
        }
        p.pinnedMessageNumLines = numLines
}

func (p *Progress) renderTracker(out *strings.Builder, t *Tracker, hint renderHint) {
        message := t.message()
        // Optimize: only process if message contains tabs or carriage returns
        if strings.ContainsAny(message, "\t\r") {
                message = strings.ReplaceAll(message, "\t", "    ")
                message = strings.ReplaceAll(message, "\r", "")
        }
        if p.lengthMessage > 0 {
                messageLen := text.StringWidthWithoutEscSequences(message)
                if messageLen < p.lengthMessage {
                        message = text.Pad(message, p.lengthMessage, ' ')
                } else {
                        message = text.Snip(message, p.lengthMessage, p.style.Options.SnipIndicator)
                }
        }

        tOut := &strings.Builder{}
        tOut.Grow(p.lengthProgressOverall)
        if hint.isOverallTracker {
                if !t.IsDone() {
                        hint := renderHint{hideValue: true, isOverallTracker: true, terminalWidth: hint.terminalWidth}
                        p.renderTrackerProgress(tOut, t, message, p.generateTrackerStr(t, p.lengthProgressOverall, hint), hint)
                }
        } else {
                if t.IsDone() {
                        p.renderTrackerDone(tOut, t, message)
                } else {
                        hint := renderHint{hideTime: !p.style.Visibility.Time, hideValue: !p.style.Visibility.Value, terminalWidth: hint.terminalWidth}
                        p.renderTrackerProgress(tOut, t, message, p.generateTrackerStr(t, p.lengthProgress, hint), hint)
                }
        }

        outStr := tOut.String()
        if hint.terminalWidth > 0 {
                outStr = text.Trim(outStr, hint.terminalWidth)
        }
        out.WriteString(outStr)
        out.WriteRune('\n')
}

func (p *Progress) renderTrackerDone(out *strings.Builder, t *Tracker, message string) {
        if !t.RemoveOnCompletion {
                out.WriteString(p.style.Colors.Message.Sprint(message))
                out.WriteString(p.style.Colors.Message.Sprint(p.style.Options.Separator))
                if !t.IsErrored() {
                        out.WriteString(p.style.Colors.Message.Sprint(p.style.Options.DoneString))
                } else {
                        out.WriteString(p.style.Colors.Error.Sprint(p.style.Options.ErrorString))
                }
                p.renderTrackerStats(out, t, renderHint{hideTime: !p.style.Visibility.Time, hideValue: !p.style.Visibility.Value})
        }
}

func (p *Progress) renderTrackerMessage(out *strings.Builder, t *Tracker, message string) {
        if !t.IsErrored() {
                out.WriteString(p.style.Colors.Message.Sprint(message))
        } else {
                out.WriteString(p.style.Colors.Error.Sprint(message))
        }
}

func (p *Progress) renderTrackerPercentage(out *strings.Builder, t *Tracker) {
        if p.style.Visibility.Percentage {
                var percentageStr string
                if t.IsIndeterminate() {
                        percentageStr = p.style.Options.PercentIndeterminate
                } else {
                        percentageStr = fmt.Sprintf(p.style.Options.PercentFormat, t.PercentDone())
                }
                out.WriteString(p.style.Colors.Percent.Sprint(percentageStr))
        }
}

func (p *Progress) renderTrackerProgress(out *strings.Builder, t *Tracker, message string, trackerStr string, hint renderHint) {
        if hint.isOverallTracker {
                out.WriteString(p.style.Colors.Tracker.Sprint(trackerStr))
                p.renderTrackerStats(out, t, hint)
        } else if p.trackerPosition == PositionRight {
                p.renderTrackerMessage(out, t, message)
                out.WriteString(p.style.Colors.Message.Sprint(p.style.Options.Separator))
                p.renderTrackerPercentage(out, t)
                if p.style.Visibility.Tracker {
                        out.WriteString(p.style.Colors.Tracker.Sprint(" " + trackerStr))
                }
                p.renderTrackerStats(out, t, hint)
        } else {
                p.renderTrackerPercentage(out, t)
                if p.style.Visibility.Tracker {
                        out.WriteString(p.style.Colors.Tracker.Sprint(" " + trackerStr))
                }
                p.renderTrackerStats(out, t, hint)
                out.WriteString(p.style.Colors.Message.Sprint(p.style.Options.Separator))
                p.renderTrackerMessage(out, t, message)
        }
}

func (p *Progress) renderTrackers(lastRenderLength int) int {
        if p.LengthActive() == 0 {
                return 0
        }

        // Cache terminal width once per render cycle to avoid repeated mutex locks
        terminalWidth := p.getTerminalWidth()
        hint := renderHint{terminalWidth: terminalWidth}

        // buffer all output into a strings.Builder object
        var out strings.Builder
        out.Grow(lastRenderLength)

        // move up N times based on the number of active trackers
        if lastRenderLength > 0 {
                p.moveCursorToTheTop(&out)
        }

        if p.style.Options.KeepTrackersTogether {
                // flush logs above the rewindable region; moveCursorToTheTop does not count them
                p.renderLogs(&out)
                p.renderTrackersDoneAndActive(&out, hint)
        } else {
                p.renderTrackersScrollback(&out, hint)
        }

        // render the overall tracker
        if p.style.Visibility.TrackerOverall {
                overallHint := renderHint{isOverallTracker: true, terminalWidth: terminalWidth}
                p.renderTracker(&out, p.overallTracker, overallHint)
        }

        // write the text to the output writer
        p.outputWriterMutex.Lock()
        _, _ = p.outputWriter.Write([]byte(out.String()))
        p.outputWriterMutex.Unlock()

        // stop if auto stop is enabled and there are no more active trackers
        if p.autoStop && p.LengthActive() == 0 {
                p.renderContextCancelMutex.Lock()
                if p.renderContextCancel != nil {
                        p.renderContextCancel()
                }
                p.renderContextCancelMutex.Unlock()
        }

        return out.Len()
}

// renderTrackersScrollback emits newly-done trackers and logs as one-shot
// scrollback above the rewindable region (pinned + still-active). This is the
// pre-v6.7.8 layout used when StyleOptions.KeepTrackersTogether is false.
func (p *Progress) renderTrackersScrollback(out *strings.Builder, hint renderHint) {
        trackersActive, trackersNewlyDone := p.extractDoneAndActiveTrackers()

        // newly-done trackers -> scrollback
        for _, tracker := range trackersNewlyDone {
                p.renderTracker(out, tracker, hint)
        }
        p.trackersDoneMutex.Lock()
        p.trackersDone = append(p.trackersDone, trackersNewlyDone...)
        p.trackersDoneMutex.Unlock()

        // logs -> scrollback, between newly-done and the rewindable region
        p.renderLogs(out)

        // pinned (part of rewindable region)
        if len(trackersActive) > 0 && p.style.Visibility.Pinned {
                p.renderPinnedMessages(out, hint)
        }

        // active trackers (part of rewindable region)
        for _, tracker := range trackersActive {
                p.renderTracker(out, tracker, hint)
        }
        p.trackersActiveMutex.Lock()
        p.trackersActive = trackersActive
        p.trackersActiveMutex.Unlock()
}

func (p *Progress) renderTrackersDoneAndActive(out *strings.Builder, hint renderHint) {
        // Extract all trackers (both active and done)
        allTrackers := p.extractAllTrackersInOrder()

        // Separate done and active trackers for sorting and state management
        trackersDone, trackersActive := p.separateDoneAndActiveTrackers(allTrackers)

        // Sort trackers based on sortBy setting
        trackersToRender := p.sortTrackersForRendering(allTrackers, trackersDone, trackersActive)

        // Render all trackers in the determined order
        for _, tracker := range trackersToRender {
                p.renderTracker(out, tracker, hint)
        }

        // Update internal state
        p.trackersDoneMutex.Lock()
        // Only add newly done trackers that aren't already in trackersDone
        existingDone := make(map[*Tracker]bool)
        for _, t := range p.trackersDone {
                existingDone[t] = true
        }
        for _, t := range trackersDone {
                if !existingDone[t] {
                        p.trackersDone = append(p.trackersDone, t)
                }
        }
        p.trackersDoneMutex.Unlock()

        p.trackersActiveMutex.Lock()
        p.trackersActive = trackersActive
        p.trackersActiveMutex.Unlock()

        // render pinned messages
        if len(trackersActive) > 0 && p.style.Visibility.Pinned {
                p.renderPinnedMessages(out, hint)
        }
}

func (p *Progress) renderLogs(out *strings.Builder) {
        p.logsToRenderMutex.Lock()
        defer p.logsToRenderMutex.Unlock()
        for _, log := range p.logsToRender {
                out.WriteString(text.EraseLine.Sprint())
                out.WriteString(log)
                out.WriteRune('\n')
        }
        p.logsToRender = nil
}

func (p *Progress) renderTrackerStats(out *strings.Builder, t *Tracker, hint renderHint) {
        if !hint.hideValue || !hint.hideTime {
                var outStats strings.Builder
                outStats.WriteString(" [")

                if p.style.Options.SpeedPosition == PositionLeft {
                        p.renderTrackerStatsSpeed(&outStats, t, hint)
                }
                if !hint.hideValue {
                        outStats.WriteString(p.style.Colors.Value.Sprint(t.Units.Sprint(t.Value())))
                }
                if !hint.hideValue && !hint.hideTime {
                        outStats.WriteString(" in ")
                }
                if !hint.hideTime {
                        p.renderTrackerStatsTime(&outStats, t, hint)
                }
                if p.style.Options.SpeedPosition == PositionRight {
                        p.renderTrackerStatsSpeed(&outStats, t, hint)
                }
                outStats.WriteRune(']')

                out.WriteString(p.style.Colors.Stats.Sprint(outStats.String()))
        }
}

func (p *Progress) renderTrackerStatsETA(out *strings.Builder, t *Tracker, hint renderHint) {
        if hint.isOverallTracker && !p.style.Visibility.ETAOverall {
                return
        }
        if !hint.isOverallTracker && !p.style.Visibility.ETA {
                return
        }

        tpETA := p.style.Options.ETAPrecision
        if eta := t.ETA().Round(tpETA); hint.isOverallTracker || eta > tpETA {
                out.WriteString("; ")
                out.WriteString(p.style.Options.ETAString)
                out.WriteString(": ")
                out.WriteString(p.style.Colors.Time.Sprint(eta))
        }
}

func (p *Progress) renderTrackerStatsSpeed(out *strings.Builder, t *Tracker, hint renderHint) {
        if hint.isOverallTracker && !p.style.Visibility.SpeedOverall {
                return
        }
        if !hint.isOverallTracker && !p.style.Visibility.Speed {
                return
        }

        speedPrecision := p.style.Options.SpeedPrecision
        if hint.isOverallTracker {
                speed := float64(0)

                p.trackersActiveMutex.RLock()
                for _, tracker := range p.trackersActive {
                        timeStart := tracker.timeStartValue()
                        if !timeStart.IsZero() {
                                speed += float64(tracker.Value()) / time.Since(timeStart).Round(speedPrecision).Seconds()
                        }
                }
                p.trackersActiveMutex.RUnlock()

                if speed > 0 {
                        p.renderTrackerStatsSpeedInternal(out, p.style.Options.SpeedOverallFormatter(int64(speed)))
                }
        } else {
                timeStart, timeStop, done := t.timeStartStopAndDone()
                if !timeStart.IsZero() {
                        var timeTaken time.Duration
                        if done {
                                timeTaken = timeStop.Sub(timeStart)
                        } else {
                                timeTaken = time.Since(timeStart)
                        }
                        if timeTakenRounded := timeTaken.Round(speedPrecision); timeTakenRounded > speedPrecision {
                                p.renderTrackerStatsSpeedInternal(out, t.Units.Sprint(int64(float64(t.Value())/timeTakenRounded.Seconds())))
                        }
                }
        }
}

func (p *Progress) renderTrackerStatsSpeedInternal(out *strings.Builder, speed string) {
        if p.style.Options.SpeedPosition == PositionRight {
                out.WriteString("; ")
        }
        out.WriteString(p.style.Colors.Speed.Sprint(speed))
        out.WriteString(p.style.Options.SpeedSuffix)
        if p.style.Options.SpeedPosition == PositionLeft {
                out.WriteString("; ")
        }
}

func (p *Progress) renderTrackerStatsTime(outStats *strings.Builder, t *Tracker, hint renderHint) {
        var td, tp time.Duration
        timeStart, timeStop, done := t.timeStartStopAndDone()
        if !timeStart.IsZero() {
                if done {
                        td = timeStop.Sub(timeStart)
                } else {
                        td = time.Since(timeStart)
                }
        }
        if hint.isOverallTracker {
                tp = p.style.Options.TimeOverallPrecision
        } else if done {
                tp = p.style.Options.TimeDonePrecision
        } else {
                tp = p.style.Options.TimeInProgressPrecision
        }
        outStats.WriteString(p.style.Colors.Time.Sprint(td.Round(tp)))

        p.renderTrackerStatsETA(outStats, t, hint)
}

func (p *Progress) separateDoneAndActiveTrackers(allTrackers []*Tracker) ([]*Tracker, []*Tracker) {
        var trackersDone, trackersActive []*Tracker
        for _, tracker := range allTrackers {
                if tracker.IsDone() {
                        if !tracker.RemoveOnCompletion {
                                trackersDone = append(trackersDone, tracker)
                        }
                } else {
                        trackersActive = append(trackersActive, tracker)
                }
        }
        return trackersDone, trackersActive
}

func (p *Progress) sortTrackersForRendering(allTrackers []*Tracker, trackersDone []*Tracker, trackersActive []*Tracker) []*Tracker {
        if p.sortBy == SortByIndex || p.sortBy == SortByIndexDsc {
                // For explicit index ordering (ascending or descending), all trackers are already sorted together
                return allTrackers
        }
        // For other sort methods, sort done and active separately, then combine
        p.sortBy.Sort(trackersDone)
        p.sortBy.Sort(trackersActive)
        // Combine: done first, then active
        return append(trackersDone, trackersActive...)
}

func (p *Progress) updateOverallTrackerProgress(allTrackers []*Tracker, activeTrackersProgress int64, maxETA time.Duration) {
        doneCount := 0
        for _, tracker := range allTrackers {
                if tracker.IsDone() {
                        doneCount++
                }
        }
        p.overallTracker.value = int64(doneCount) * 100
        p.overallTracker.value += activeTrackersProgress
        p.overallTracker.minETA = maxETA
        if len(allTrackers) > 0 && doneCount == len(allTrackers) {
                p.overallTracker.MarkAsDone()
        }
}

jedib0t / go-pretty / 26191557037

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous