From 13d3a1d863058dc90a56474478461547a60d6c44 Mon Sep 17 00:00:00 2001
From: Nathan Baulch <nathan.baulch@gmail.com>
Date: Sun, 27 Aug 2023 03:45:10 +1000
Subject: [PATCH] progress: render never started trackers properly (#273)

---
 .github/workflows/ci.yml  |  2 +-
 README.md                 |  2 +-
 cmd/demo-progress/demo.go |  2 +-
 list/list.go              | 12 ++----
 list/render.go            | 14 +++---
 list/render_test.go       |  1 -
 list/writer.go            |  2 +-
 progress/progress.go      |  4 +-
 progress/progress_test.go |  4 +-
 progress/render.go        | 20 ++++-----
 progress/render_test.go   | 86 +++++++++++++++++++++++--------------
 progress/style.go         | 68 ++++++++++++++---------------
 progress/units.go         | 16 +++----
 progress/writer.go        |  2 +-
 table/render_bidi_test.go |  1 -
 table/render_html.go      |  4 +-
 table/render_init.go      |  8 +---
 table/render_markdown.go  | 22 ++++------
 table/style.go            | 30 ++++++-------
 table/table.go            | 29 +++++++------
 table/util.go             |  2 +-
 table/writer.go           |  2 +-
 text/align.go             |  2 +-
 text/ansi_windows.go      |  4 +-
 text/color.go             | 12 ++----
 text/color_html.go        | 90 +++++++++++++++++++--------------------
 text/escape.go            |  1 -
 text/transformer.go       | 14 +++---
 28 files changed, 221 insertions(+), 235 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index da20a9c..779b58c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,7 +21,7 @@ jobs:
       - name: Checkout Code
         uses: actions/checkout@v2
 
-      # Set up the GoLang enviroment
+      # Set up the GoLang environment
       - name: Set up Go
         uses: actions/setup-go@v2
         with:
diff --git a/README.md b/README.md
index d49294a..af77db9 100644
--- a/README.md
+++ b/README.md
@@ -111,4 +111,4 @@ the following from within your code folder to do the same:
 ```
 find . -type f -name "*.go" | grep -v vendor | xargs sed -i 's/jedib0t\/go-pretty\//jedib0t\/go-pretty\/v6\//g'
 ```
-If you are on MacOS, you'll have to use `sed -i ''` instead of `sed -i`.
+If you are on macOS, you'll have to use `sed -i ''` instead of `sed -i`.
diff --git a/cmd/demo-progress/demo.go b/cmd/demo-progress/demo.go
index e6baa7a..0bc6b1d 100644
--- a/cmd/demo-progress/demo.go
+++ b/cmd/demo-progress/demo.go
@@ -97,7 +97,7 @@ func trackSomething(pw progress.Writer, idx int64, updateMessage bool) {
 			}
 			pw.SetPinnedMessages(
 				fmt.Sprintf(">> Current Time: %-32s", time.Now().Format(time.RFC3339)),
-				fmt.Sprintf(">>   Total Time: %-32s", time.Now().Sub(timeStart).Round(time.Millisecond)),
+				fmt.Sprintf(">>   Total Time: %-32s", time.Since(timeStart).Round(time.Millisecond)),
 			)
 		case <-updateTicker:
 			if updateMessage {
diff --git a/list/list.go b/list/list.go
index 64e5393..9f8cffe 100644
--- a/list/list.go
+++ b/list/list.go
@@ -19,7 +19,7 @@ type listItem struct {
 	Text  string
 }
 
-// List helps print a 2-dimensional array in a human readable pretty-List.
+// List helps print a 2-dimensional array in a human-readable pretty-List.
 type List struct {
 	// approxSize stores the approximate output length/size
 	approxSize int
@@ -71,7 +71,7 @@ func (l *List) Reset() {
 	l.style = nil
 }
 
-// SetHTMLCSSClass sets the the HTML CSS Class to use on the <ul> node
+// SetHTMLCSSClass sets the HTML CSS Class to use on the <ul> node
 // when rendering the List in HTML format. Recursive lists would use a numbered
 // index suffix. For ex., if the cssClass is set as "foo"; the <ul> for level 0
 // would have the class set as "foo"; the <ul> for level 1 would have "foo-1".
@@ -101,12 +101,8 @@ func (l *List) Style() *Style {
 
 func (l *List) analyzeAndStringify(item interface{}) *listItem {
 	itemStr := fmt.Sprint(item)
-	if strings.Contains(itemStr, "\t") {
-		itemStr = strings.Replace(itemStr, "\t", "    ", -1)
-	}
-	if strings.Contains(itemStr, "\r") {
-		itemStr = strings.Replace(itemStr, "\r", "", -1)
-	}
+	itemStr = strings.ReplaceAll(itemStr, "\t", "    ")
+	itemStr = strings.ReplaceAll(itemStr, "\r", "")
 	return &listItem{
 		Level: l.level,
 		Text:  itemStr,
diff --git a/list/render.go b/list/render.go
index 5e9bce7..935416d 100644
--- a/list/render.go
+++ b/list/render.go
@@ -22,10 +22,10 @@ func (l *List) Render() string {
 	out.Grow(l.approxSize)
 	for idx, item := range l.items {
 		hint := renderHint{
-			isTopItem:    bool(idx == 0),
-			isFirstItem:  bool(idx == 0 || item.Level > l.items[idx-1].Level),
+			isTopItem:    idx == 0,
+			isFirstItem:  idx == 0 || item.Level > l.items[idx-1].Level,
 			isLastItem:   !l.hasMoreItemsInLevel(item.Level, idx),
-			isBottomItem: bool(idx == len(l.items)-1),
+			isBottomItem: idx == len(l.items)-1,
 		}
 		if hint.isFirstItem && hint.isLastItem {
 			hint.isOnlyItem = true
@@ -56,7 +56,7 @@ func (l *List) renderItem(out *strings.Builder, idx int, item *listItem, hint re
 		}
 
 		// render the prefix or the leading text before the actual item
-		l.renderItemBulletPrefix(out, idx, item.Level, lineIdx, hint)
+		l.renderItemBulletPrefix(out, idx, item.Level)
 		l.renderItemBullet(out, lineIdx, hint)
 
 		// render the actual item
@@ -73,11 +73,11 @@ func (l *List) renderItemBullet(out *strings.Builder, lineIdx int, hint renderHi
 			out.WriteString(l.style.CharItemVertical)
 		}
 	} else {
-		l.renderItemBulletSingleLine(out, lineIdx, hint)
+		l.renderItemBulletSingleLine(out, hint)
 	}
 }
 
-func (l *List) renderItemBulletSingleLine(out *strings.Builder, lineIdx int, hint renderHint) {
+func (l *List) renderItemBulletSingleLine(out *strings.Builder, hint renderHint) {
 	// single-line item.Text (or first line of a multi-line item.Text)
 	if hint.isOnlyItem {
 		if hint.isTopItem {
@@ -97,7 +97,7 @@ func (l *List) renderItemBulletSingleLine(out *strings.Builder, lineIdx int, hin
 	out.WriteRune(' ')
 }
 
-func (l *List) renderItemBulletPrefix(out *strings.Builder, itemIdx int, itemLevel int, lineIdx int, hint renderHint) {
+func (l *List) renderItemBulletPrefix(out *strings.Builder, itemIdx int, itemLevel int) {
 	// write a prefix if one has been set in l.style
 	if l.style.LinePrefix != "" {
 		out.WriteString(l.style.LinePrefix)
diff --git a/list/render_test.go b/list/render_test.go
index d493b9d..8555472 100644
--- a/list/render_test.go
+++ b/list/render_test.go
@@ -331,5 +331,4 @@ func TestList_Render_UnindentAll(t *testing.T) {
         * Way
 * Right?`
 	assert.Equal(t, expectedOut, lw.Render())
-
 }
diff --git a/list/writer.go b/list/writer.go
index 62350b2..b68bf9c 100644
--- a/list/writer.go
+++ b/list/writer.go
@@ -2,7 +2,7 @@ package list
 
 import "io"
 
-// Writer declares the interfaces that can be used to setup and render a list.
+// Writer declares the interfaces that can be used to set up and render a list.
 type Writer interface {
 	AppendItem(item interface{})
 	AppendItems(items []interface{})
diff --git a/progress/progress.go b/progress/progress.go
index 12ca71b..26960c9 100644
--- a/progress/progress.go
+++ b/progress/progress.go
@@ -199,7 +199,7 @@ func (p *Progress) SetPinnedMessages(messages ...string) {
 }
 
 // SetSortBy defines the sorting mechanism to use to sort the Active Trackers
-// before rendering the. Default: no-sorting == sort-by-insertion-order.
+// before rendering. Default: no-sorting == sort-by-insertion-order.
 func (p *Progress) SetSortBy(sortBy SortBy) {
 	p.sortBy = sortBy
 }
@@ -221,7 +221,7 @@ func (p *Progress) SetTrackerPosition(position Position) {
 }
 
 // SetUpdateFrequency sets the update frequency while rendering the trackers.
-// the lower the value, the more number of times the Trackers get refreshed. A
+// the lower the value, the more frequently the Trackers get refreshed. A
 // sane value would be 250ms.
 func (p *Progress) SetUpdateFrequency(frequency time.Duration) {
 	p.updateFrequency = frequency
diff --git a/progress/progress_test.go b/progress/progress_test.go
index 6ff4c7e..e5f94de 100644
--- a/progress/progress_test.go
+++ b/progress/progress_test.go
@@ -169,8 +169,8 @@ func TestProgress_SetUpdateFrequency(t *testing.T) {
 	p.initForRender()
 	assert.Equal(t, DefaultUpdateFrequency, p.updateFrequency)
 
-	p.SetUpdateFrequency(time.Duration(time.Second))
-	assert.Equal(t, time.Duration(time.Second), p.updateFrequency)
+	p.SetUpdateFrequency(time.Second)
+	assert.Equal(t, time.Second, p.updateFrequency)
 }
 
 func TestProgress_ShowETA(t *testing.T) {
diff --git a/progress/render.go b/progress/render.go
index 73dfec5..30fcd77 100644
--- a/progress/render.go
+++ b/progress/render.go
@@ -149,7 +149,7 @@ func (p *Progress) generateTrackerStrIndeterminate(maxLen int) string {
 	}
 
 	return p.style.Colors.Tracker.Sprintf("%s%s%s",
-		p.style.Chars.BoxLeft, string(pUnfinished), p.style.Chars.BoxRight,
+		p.style.Chars.BoxLeft, pUnfinished, p.style.Chars.BoxRight,
 	)
 }
 
@@ -185,12 +185,8 @@ func (p *Progress) renderPinnedMessages(out *strings.Builder) {
 
 func (p *Progress) renderTracker(out *strings.Builder, t *Tracker, hint renderHint) {
 	message := t.message()
-	if strings.Contains(message, "\t") {
-		message = strings.Replace(message, "\t", "    ", -1)
-	}
-	if strings.Contains(message, "\r") {
-		message = strings.Replace(message, "\r", "", -1)
-	}
+	message = strings.ReplaceAll(message, "\t", "    ")
+	message = strings.ReplaceAll(message, "\r", "")
 	if p.messageWidth > 0 {
 		messageLen := text.RuneWidthWithoutEscSequences(message)
 		if messageLen < p.messageWidth {
@@ -412,10 +408,12 @@ func (p *Progress) renderTrackerStatsSpeedInternal(out *strings.Builder, speed s
 
 func (p *Progress) renderTrackerStatsTime(outStats *strings.Builder, t *Tracker, hint renderHint) {
 	var td, tp time.Duration
-	if t.IsDone() {
-		td = t.timeStop.Sub(t.timeStart)
-	} else if !t.timeStart.IsZero() {
-		td = time.Since(t.timeStart)
+	if !t.timeStart.IsZero() {
+		if t.IsDone() {
+			td = t.timeStop.Sub(t.timeStart)
+		} else {
+			td = time.Since(t.timeStart)
+		}
 	}
 	if hint.isOverallTracker {
 		tp = p.style.Options.TimeOverallPrecision
diff --git a/progress/render_test.go b/progress/render_test.go
index f1362be..df0adc8 100644
--- a/progress/render_test.go
+++ b/progress/render_test.go
@@ -55,13 +55,11 @@ func trackSomething(pw Writer, tracker *Tracker) {
 
 	c := time.Tick(trackerIncrementInterval)
 	for !tracker.IsDone() {
-		select {
-		case <-c:
-			if tracker.value+incrementPerCycle > tracker.Total {
-				tracker.Increment(tracker.Total - tracker.value)
-			} else {
-				tracker.Increment(incrementPerCycle)
-			}
+		<-c
+		if tracker.value+incrementPerCycle > tracker.Total {
+			tracker.Increment(tracker.Total - tracker.value)
+		} else {
+			tracker.Increment(incrementPerCycle)
 		}
 	}
 }
@@ -75,15 +73,13 @@ func trackSomethingDeferred(pw Writer, tracker *Tracker) {
 
 	c := time.Tick(trackerIncrementInterval)
 	for !tracker.IsDone() {
-		select {
-		case <-c:
-			if skip {
-				skip = false
-			} else if tracker.value+incrementPerCycle > tracker.Total {
-				tracker.Increment(tracker.Total - tracker.value)
-			} else {
-				tracker.Increment(incrementPerCycle)
-			}
+		<-c
+		if skip {
+			skip = false
+		} else if tracker.value+incrementPerCycle > tracker.Total {
+			tracker.Increment(tracker.Total - tracker.value)
+		} else {
+			tracker.Increment(incrementPerCycle)
 		}
 	}
 }
@@ -97,13 +93,11 @@ func trackSomethingErrored(pw Writer, tracker *Tracker) {
 
 	c := time.Tick(trackerIncrementInterval)
 	for !tracker.IsDone() {
-		select {
-		case <-c:
-			if tracker.value+incrementPerCycle > total {
-				tracker.MarkAsErrored()
-			} else {
-				tracker.IncrementWithError(incrementPerCycle)
-			}
+		<-c
+		if tracker.value+incrementPerCycle > total {
+			tracker.MarkAsErrored()
+		} else {
+			tracker.IncrementWithError(incrementPerCycle)
 		}
 	}
 }
@@ -117,16 +111,14 @@ func trackSomethingIndeterminate(pw Writer, tracker *Tracker) {
 
 	c := time.Tick(trackerIncrementInterval)
 	for !tracker.IsDone() {
-		select {
-		case <-c:
-			if tracker.value+incrementPerCycle > total {
-				tracker.Increment(total - tracker.value)
-			} else {
-				tracker.Increment(incrementPerCycle)
-			}
-			if tracker.Value() >= total {
-				tracker.MarkAsDone()
-			}
+		<-c
+		if tracker.value+incrementPerCycle > total {
+			tracker.Increment(total - tracker.value)
+		} else {
+			tracker.Increment(incrementPerCycle)
+		}
+		if tracker.Value() >= total {
+			tracker.MarkAsDone()
 		}
 	}
 }
@@ -338,6 +330,34 @@ func TestProgress_generateTrackerStr_Indeterminate(t *testing.T) {
 	}
 }
 
+func TestProgress_RenderNeverStarted(t *testing.T) {
+	renderOutput := strings.Builder{}
+
+	pw := generateWriter()
+	pw.SetOutputWriter(&renderOutput)
+
+	tr := &Tracker{DeferStart: true}
+	pw.AppendTracker(tr)
+
+	go pw.Render()
+	time.Sleep(renderWaitTime)
+	tr.MarkAsDone()
+	pw.Stop()
+	time.Sleep(time.Second)
+
+	expectedOutPatterns := []*regexp.Regexp{
+		regexp.MustCompile(`\s*\.\.\. {2}\?\?\? {2}\[\.{23}] \[0 in 0s]`),
+		regexp.MustCompile(`\s*\.\.\. done! \[0 in 0s]`),
+	}
+	out := renderOutput.String()
+	for _, expectedOutPattern := range expectedOutPatterns {
+		if !expectedOutPattern.MatchString(out) {
+			assert.Fail(t, "Failed to find a pattern in the Output.", expectedOutPattern.String())
+		}
+	}
+	showOutputOnFailure(t, out)
+}
+
 func TestProgress_RenderNothing(t *testing.T) {
 	renderOutput := outputWriter{}
 
diff --git a/progress/style.go b/progress/style.go
index 50f1945..1ab8aad 100644
--- a/progress/style.go
+++ b/progress/style.go
@@ -168,27 +168,25 @@ type StyleOptions struct {
 	TimeOverallPrecision    time.Duration  // precision for overall time
 }
 
-var (
-	// StyleOptionsDefault defines sane defaults for the Options. Use this as an
-	// example to customize the Tracker rendering.
-	StyleOptionsDefault = StyleOptions{
-		DoneString:              "done!",
-		ErrorString:             "fail!",
-		ETAPrecision:            time.Second,
-		ETAString:               "~ETA",
-		PercentFormat:           "%5.2f%%",
-		PercentIndeterminate:    " ??? ",
-		Separator:               " ... ",
-		SnipIndicator:           "~",
-		SpeedPosition:           PositionRight,
-		SpeedPrecision:          time.Microsecond,
-		SpeedOverallFormatter:   FormatNumber,
-		SpeedSuffix:             "/s",
-		TimeDonePrecision:       time.Millisecond,
-		TimeInProgressPrecision: time.Microsecond,
-		TimeOverallPrecision:    time.Second,
-	}
-)
+// StyleOptionsDefault defines sane defaults for the Options. Use this as an
+// example to customize the Tracker rendering.
+var StyleOptionsDefault = StyleOptions{
+	DoneString:              "done!",
+	ErrorString:             "fail!",
+	ETAPrecision:            time.Second,
+	ETAString:               "~ETA",
+	PercentFormat:           "%5.2f%%",
+	PercentIndeterminate:    " ??? ",
+	Separator:               " ... ",
+	SnipIndicator:           "~",
+	SpeedPosition:           PositionRight,
+	SpeedPrecision:          time.Microsecond,
+	SpeedOverallFormatter:   FormatNumber,
+	SpeedSuffix:             "/s",
+	TimeDonePrecision:       time.Millisecond,
+	TimeInProgressPrecision: time.Microsecond,
+	TimeOverallPrecision:    time.Second,
+}
 
 // StyleVisibility controls what gets shown and what gets hidden.
 type StyleVisibility struct {
@@ -204,18 +202,16 @@ type StyleVisibility struct {
 	Value          bool // tracker value
 }
 
-var (
-	// StyleVisibilityDefault defines sane defaults for the Visibility.
-	StyleVisibilityDefault = StyleVisibility{
-		ETA:            false,
-		ETAOverall:     true,
-		Percentage:     true,
-		Pinned:         true,
-		Speed:          false,
-		SpeedOverall:   false,
-		Time:           true,
-		Tracker:        true,
-		TrackerOverall: false,
-		Value:          true,
-	}
-)
+// StyleVisibilityDefault defines sane defaults for the Visibility.
+var StyleVisibilityDefault = StyleVisibility{
+	ETA:            false,
+	ETAOverall:     true,
+	Percentage:     true,
+	Pinned:         true,
+	Speed:          false,
+	SpeedOverall:   false,
+	Time:           true,
+	Tracker:        true,
+	TrackerOverall: false,
+	Value:          true,
+}
diff --git a/progress/units.go b/progress/units.go
index a21c3db..3591116 100644
--- a/progress/units.go
+++ b/progress/units.go
@@ -109,15 +109,13 @@ func FormatNumber(value int64) string {
 	})
 }
 
-var (
-	unitScales = []int64{
-		1000000000000000,
-		1000000000000,
-		1000000000,
-		1000000,
-		1000,
-	}
-)
+var unitScales = []int64{
+	1000000000000000,
+	1000000000000,
+	1000000000,
+	1000000,
+	1000,
+}
 
 func formatNumber(value int64, notations map[int64]string) string {
 	for _, unitScale := range unitScales {
diff --git a/progress/writer.go b/progress/writer.go
index 71863f1..0e6d7bc 100644
--- a/progress/writer.go
+++ b/progress/writer.go
@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-// Writer declares the interfaces that can be used to setup and render a
+// Writer declares the interfaces that can be used to set up and render a
 // Progress tracker with one or more trackers.
 type Writer interface {
 	AppendTracker(tracker *Tracker)
diff --git a/table/render_bidi_test.go b/table/render_bidi_test.go
index 9b0fd66..79b7d95 100644
--- a/table/render_bidi_test.go
+++ b/table/render_bidi_test.go
@@ -15,7 +15,6 @@ func TestTable_Render_BiDiText(t *testing.T) {
 	table.AppendFooter(Row{"סהכ", 30})
 	table.SetAutoIndex(true)
 
-	//table.Style().Format.Direction = text.Default
 	compareOutput(t, table.Render(), `
 +---+------------+------+--------+-----------+
 |   | תאריך      | סכום | מחלקה  | תגים      |
diff --git a/table/render_html.go b/table/render_html.go
index 10a7325..bf712ec 100644
--- a/table/render_html.go
+++ b/table/render_html.go
@@ -112,7 +112,7 @@ func (t *Table) htmlRenderColumn(out *strings.Builder, colStr string) {
 	out.WriteString(colStr)
 }
 
-func (t *Table) htmlRenderColumnAttributes(out *strings.Builder, row rowStr, colIdx int, hint renderHint) {
+func (t *Table) htmlRenderColumnAttributes(out *strings.Builder, colIdx int, hint renderHint) {
 	// determine the HTML "align"/"valign" property values
 	align := t.getAlign(colIdx, hint).HTMLProperty()
 	vAlign := t.getVAlign(colIdx, hint).HTMLProperty()
@@ -161,7 +161,7 @@ func (t *Table) htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
 		// write the row
 		out.WriteString("    <")
 		out.WriteString(colTagName)
-		t.htmlRenderColumnAttributes(out, row, colIdx, hint)
+		t.htmlRenderColumnAttributes(out, colIdx, hint)
 		out.WriteString(">")
 		if len(colStr) == 0 {
 			out.WriteString(t.style.HTML.EmptyColumn)
diff --git a/table/render_init.go b/table/render_init.go
index c6fd97c..917879b 100644
--- a/table/render_init.go
+++ b/table/render_init.go
@@ -43,12 +43,8 @@ func (t *Table) analyzeAndStringifyColumn(colIdx int, col interface{}, hint rend
 	} else {
 		colStr = fmt.Sprint(col)
 	}
-	if strings.Contains(colStr, "\t") {
-		colStr = strings.Replace(colStr, "\t", "    ", -1)
-	}
-	if strings.Contains(colStr, "\r") {
-		colStr = strings.Replace(colStr, "\r", "", -1)
-	}
+	colStr = strings.ReplaceAll(colStr, "\t", "    ")
+	colStr = strings.ReplaceAll(colStr, "\r", "")
 	return fmt.Sprintf("%s%s", t.style.Format.Direction.Modifier(), colStr)
 }
 
diff --git a/table/render_markdown.go b/table/render_markdown.go
index 127adcd..adf573f 100644
--- a/table/render_markdown.go
+++ b/table/render_markdown.go
@@ -6,12 +6,13 @@ import (
 )
 
 // RenderMarkdown renders the Table in Markdown format. Example:
-//  | # | First Name | Last Name | Salary |  |
-//  | ---:| --- | --- | ---:| --- |
-//  | 1 | Arya | Stark | 3000 |  |
-//  | 20 | Jon | Snow | 2000 | You know nothing, Jon Snow! |
-//  | 300 | Tyrion | Lannister | 5000 |  |
-//  |  |  | Total | 10000 |  |
+//
+//	| # | First Name | Last Name | Salary |  |
+//	| ---:| --- | --- | ---:| --- |
+//	| 1 | Arya | Stark | 3000 |  |
+//	| 20 | Jon | Snow | 2000 | You know nothing, Jon Snow! |
+//	| 300 | Tyrion | Lannister | 5000 |  |
+//	|  |  | Total | 10000 |  |
 func (t *Table) RenderMarkdown() string {
 	t.initForRender()
 
@@ -54,12 +55,8 @@ func (t *Table) markdownRenderRow(out *strings.Builder, row rowStr, hint renderH
 				colStr = row[colIdx]
 			}
 			out.WriteRune(' ')
-			if strings.Contains(colStr, "|") {
-				colStr = strings.Replace(colStr, "|", "\\|", -1)
-			}
-			if strings.Contains(colStr, "\n") {
-				colStr = strings.Replace(colStr, "\n", "<br/>", -1)
-			}
+			colStr = strings.ReplaceAll(colStr, "|", "\\|")
+			colStr = strings.ReplaceAll(colStr, "\n", "<br/>")
 			out.WriteString(colStr)
 			out.WriteRune(' ')
 		}
@@ -94,7 +91,6 @@ func (t *Table) markdownRenderRows(out *strings.Builder, rows []rowStr, hint ren
 
 func (t *Table) markdownRenderRowsFooter(out *strings.Builder) {
 	t.markdownRenderRows(out, t.rowsFooter, renderHint{isFooterRow: true})
-
 }
 
 func (t *Table) markdownRenderRowsHeader(out *strings.Builder) {
diff --git a/table/style.go b/table/style.go
index ee87ef8..cb850e8 100644
--- a/table/style.go
+++ b/table/style.go
@@ -675,14 +675,12 @@ type FormatOptions struct {
 	Row       text.Format    // (data) row(s) text format
 }
 
-var (
-	// FormatOptionsDefault defines sensible formatting options.
-	FormatOptionsDefault = FormatOptions{
-		Footer: text.FormatUpper,
-		Header: text.FormatUpper,
-		Row:    text.FormatDefault,
-	}
-)
+// FormatOptionsDefault defines sensible formatting options.
+var FormatOptionsDefault = FormatOptions{
+	Footer: text.FormatUpper,
+	Header: text.FormatUpper,
+	Row:    text.FormatDefault,
+}
 
 // HTMLOptions defines the global options to control HTML rendering.
 type HTMLOptions struct {
@@ -692,15 +690,13 @@ type HTMLOptions struct {
 	Newline     string // string to replace "\n" characters with
 }
 
-var (
-	// DefaultHTMLOptions defines sensible HTML rendering defaults.
-	DefaultHTMLOptions = HTMLOptions{
-		CSSClass:    DefaultHTMLCSSClass,
-		EmptyColumn: "&nbsp;",
-		EscapeText:  true,
-		Newline:     "<br/>",
-	}
-)
+// DefaultHTMLOptions defines sensible HTML rendering defaults.
+var DefaultHTMLOptions = HTMLOptions{
+	CSSClass:    DefaultHTMLCSSClass,
+	EmptyColumn: "&nbsp;",
+	EscapeText:  true,
+	Newline:     "<br/>",
+}
 
 // Options defines the global options that determine how the Table is
 // rendered.
diff --git a/table/table.go b/table/table.go
index 684974c..c04fa06 100644
--- a/table/table.go
+++ b/table/table.go
@@ -32,13 +32,13 @@ func (row rowStr) areEqual(colIdx1 int, colIdx2 int) bool {
 	return colIdx1 >= 0 && colIdx2 < len(row) && row[colIdx1] == row[colIdx2]
 }
 
-// Table helps print a 2-dimensional array in a human readable pretty-table.
+// Table helps print a 2-dimensional array in a human-readable pretty-table.
 type Table struct {
 	// allowedRowLength is the max allowed length for a row (or line of output)
 	allowedRowLength int
 	// enable automatic indexing of the rows and columns like a spreadsheet?
 	autoIndex bool
-	// autoIndexVIndexMaxLength denotes the length in chars for the last rownum
+	// autoIndexVIndexMaxLength denotes the length in chars for the last row
 	autoIndexVIndexMaxLength int
 	// caption stores the text to be rendered just below the table; and doesn't
 	// get used when rendered as a CSV
@@ -164,14 +164,15 @@ func (t *Table) AppendRows(rows []Row, config ...RowConfig) {
 // append is a separator, it will not be rendered in addition to the usual table
 // separator.
 //
-//******************************************************************************
+// ******************************************************************************
 // Please note the following caveats:
-// 1. SetPageSize(): this may end up creating consecutive separator rows near
-//    the end of a page or at the beginning of a page
-// 2. SortBy(): since SortBy could inherently alter the ordering of rows, the
-//    separators may not appear after the row it was originally intended to
-//    follow
-//******************************************************************************
+//  1. SetPageSize(): this may end up creating consecutive separator rows near
+//     the end of a page or at the beginning of a page
+//  2. SortBy(): since SortBy could inherently alter the ordering of rows, the
+//     separators may not appear after the row it was originally intended to
+//     follow
+//
+// ******************************************************************************
 func (t *Table) AppendSeparator() {
 	if t.separators == nil {
 		t.separators = make(map[int]bool)
@@ -228,7 +229,7 @@ func (t *Table) SetColumnConfigs(configs []ColumnConfig) {
 	t.columnConfigs = configs
 }
 
-// SetHTMLCSSClass sets the the HTML CSS Class to use on the <table> node
+// SetHTMLCSSClass sets the HTML CSS Class to use on the <table> node
 // when rendering the Table in HTML format.
 //
 // Deprecated: in favor of Style().HTML.CSSClass
@@ -388,7 +389,7 @@ func (t *Table) getBorderRight(hint renderHint) string {
 
 func (t *Table) getColumnColors(colIdx int, hint renderHint) text.Colors {
 	if hint.isBorderOrSeparator() {
-		if colors := t.getColumnColorsForBorderOrSeparator(colIdx, hint); colors != nil {
+		if colors := t.getColumnColorsForBorderOrSeparator(hint); colors != nil {
 			return colors
 		}
 	}
@@ -410,7 +411,7 @@ func (t *Table) getColumnColors(colIdx int, hint renderHint) text.Colors {
 	return nil
 }
 
-func (t *Table) getColumnColorsForBorderOrSeparator(colIdx int, hint renderHint) text.Colors {
+func (t *Table) getColumnColorsForBorderOrSeparator(hint renderHint) text.Colors {
 	if t.style.Options.DoNotColorBordersAndSeparators {
 		return text.Colors{} // not nil to force caller to paint with no colors
 	}
@@ -751,13 +752,13 @@ func (t *Table) shouldMergeCellsVertically(colIdx int, hint renderHint) bool {
 			rowPrev := t.getRow(hint.rowNumber-1, hint)
 			rowNext := t.getRow(hint.rowNumber, hint)
 			if colIdx < len(rowPrev) && colIdx < len(rowNext) {
-				return rowPrev[colIdx] == rowNext[colIdx] || "" == rowNext[colIdx]
+				return rowPrev[colIdx] == rowNext[colIdx] || rowNext[colIdx] == ""
 			}
 		} else {
 			rowPrev := t.getRow(hint.rowNumber-2, hint)
 			rowCurr := t.getRow(hint.rowNumber-1, hint)
 			if colIdx < len(rowPrev) && colIdx < len(rowCurr) {
-				return rowPrev[colIdx] == rowCurr[colIdx] || "" == rowCurr[colIdx]
+				return rowPrev[colIdx] == rowCurr[colIdx] || rowCurr[colIdx] == ""
 			}
 		}
 	}
diff --git a/table/util.go b/table/util.go
index e6d2ed7..aa71012 100644
--- a/table/util.go
+++ b/table/util.go
@@ -21,7 +21,7 @@ func AutoIndexColumnID(colIdx int) string {
 type WidthEnforcer func(col string, maxLen int) string
 
 // widthEnforcerNone returns the input string as is without any modifications.
-func widthEnforcerNone(col string, maxLen int) string {
+func widthEnforcerNone(col string, _ int) string {
 	return col
 }
 
diff --git a/table/writer.go b/table/writer.go
index c70ba33..c5ecb3e 100644
--- a/table/writer.go
+++ b/table/writer.go
@@ -4,7 +4,7 @@ import (
 	"io"
 )
 
-// Writer declares the interfaces that can be used to setup and render a table.
+// Writer declares the interfaces that can be used to set up and render a table.
 type Writer interface {
 	AppendFooter(row Row, configs ...RowConfig)
 	AppendHeader(row Row, configs ...RowConfig)
diff --git a/text/align.go b/text/align.go
index ade9ded..764a1f8 100644
--- a/text/align.go
+++ b/text/align.go
@@ -39,7 +39,7 @@ func (a Align) Apply(text string, maxLength int) string {
 		if sLenWoE < maxLength {
 			// left pad with half the number of spaces needed before using %text
 			return fmt.Sprintf("%"+strconv.Itoa(maxLength+numEscChars)+"s",
-				text+strings.Repeat(" ", int((maxLength-sLenWoE)/2)))
+				text+strings.Repeat(" ", (maxLength-sLenWoE)/2))
 		}
 	case AlignJustify:
 		return a.justifyText(text, sLenWoE, maxLength)
diff --git a/text/ansi_windows.go b/text/ansi_windows.go
index d2a3288..4f8b42f 100644
--- a/text/ansi_windows.go
+++ b/text/ansi_windows.go
@@ -10,9 +10,7 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-var (
-	enableVTPMutex = sync.Mutex{}
-)
+var enableVTPMutex = sync.Mutex{}
 
 func areANSICodesSupported() bool {
 	enableVTPMutex.Lock()
diff --git a/text/color.go b/text/color.go
index f5b7bdd..f42dfb3 100644
--- a/text/color.go
+++ b/text/color.go
@@ -8,9 +8,7 @@ import (
 	"sync"
 )
 
-var (
-	colorsEnabled = areANSICodesSupported()
-)
+var colorsEnabled = areANSICodesSupported()
 
 // DisableColors (forcefully) disables color coding globally.
 func DisableColors() {
@@ -23,7 +21,7 @@ func EnableColors() {
 }
 
 // The logic here is inspired from github.com/fatih/color; the following is
-// the the bare minimum logic required to print Colored to the console.
+// the bare minimum logic required to print Colored to the console.
 // The differences:
 // * This one caches the escape sequences for cases with multiple colors
 // * This one handles cases where the incoming already has colors in the
@@ -123,10 +121,8 @@ func (c Color) Sprintf(format string, a ...interface{}) string {
 // Example: Colors{FgCyan, BgBlack}
 type Colors []Color
 
-var (
-	// colorsSeqMap caches the escape sequence for a set of colors
-	colorsSeqMap = sync.Map{}
-)
+// colorsSeqMap caches the escape sequence for a set of colors
+var colorsSeqMap = sync.Map{}
 
 // EscapeSeq returns the ANSI escape sequence for the colors set.
 func (c Colors) EscapeSeq() string {
diff --git a/text/color_html.go b/text/color_html.go
index 3e5c55b..14fa174 100644
--- a/text/color_html.go
+++ b/text/color_html.go
@@ -1,48 +1,46 @@
 package text
 
-var (
-	// colorCSSClassMap contains the equivalent CSS-class for all colors
-	colorCSSClassMap = map[Color]string{
-		Bold:         "bold",
-		Faint:        "faint",
-		Italic:       "italic",
-		Underline:    "underline",
-		BlinkSlow:    "blink-slow",
-		BlinkRapid:   "blink-rapid",
-		ReverseVideo: "reverse-video",
-		Concealed:    "concealed",
-		CrossedOut:   "crossed-out",
-		FgBlack:      "fg-black",
-		FgRed:        "fg-red",
-		FgGreen:      "fg-green",
-		FgYellow:     "fg-yellow",
-		FgBlue:       "fg-blue",
-		FgMagenta:    "fg-magenta",
-		FgCyan:       "fg-cyan",
-		FgWhite:      "fg-white",
-		FgHiBlack:    "fg-hi-black",
-		FgHiRed:      "fg-hi-red",
-		FgHiGreen:    "fg-hi-green",
-		FgHiYellow:   "fg-hi-yellow",
-		FgHiBlue:     "fg-hi-blue",
-		FgHiMagenta:  "fg-hi-magenta",
-		FgHiCyan:     "fg-hi-cyan",
-		FgHiWhite:    "fg-hi-white",
-		BgBlack:      "bg-black",
-		BgRed:        "bg-red",
-		BgGreen:      "bg-green",
-		BgYellow:     "bg-yellow",
-		BgBlue:       "bg-blue",
-		BgMagenta:    "bg-magenta",
-		BgCyan:       "bg-cyan",
-		BgWhite:      "bg-white",
-		BgHiBlack:    "bg-hi-black",
-		BgHiRed:      "bg-hi-red",
-		BgHiGreen:    "bg-hi-green",
-		BgHiYellow:   "bg-hi-yellow",
-		BgHiBlue:     "bg-hi-blue",
-		BgHiMagenta:  "bg-hi-magenta",
-		BgHiCyan:     "bg-hi-cyan",
-		BgHiWhite:    "bg-hi-white",
-	}
-)
+// colorCSSClassMap contains the equivalent CSS-class for all colors
+var colorCSSClassMap = map[Color]string{
+	Bold:         "bold",
+	Faint:        "faint",
+	Italic:       "italic",
+	Underline:    "underline",
+	BlinkSlow:    "blink-slow",
+	BlinkRapid:   "blink-rapid",
+	ReverseVideo: "reverse-video",
+	Concealed:    "concealed",
+	CrossedOut:   "crossed-out",
+	FgBlack:      "fg-black",
+	FgRed:        "fg-red",
+	FgGreen:      "fg-green",
+	FgYellow:     "fg-yellow",
+	FgBlue:       "fg-blue",
+	FgMagenta:    "fg-magenta",
+	FgCyan:       "fg-cyan",
+	FgWhite:      "fg-white",
+	FgHiBlack:    "fg-hi-black",
+	FgHiRed:      "fg-hi-red",
+	FgHiGreen:    "fg-hi-green",
+	FgHiYellow:   "fg-hi-yellow",
+	FgHiBlue:     "fg-hi-blue",
+	FgHiMagenta:  "fg-hi-magenta",
+	FgHiCyan:     "fg-hi-cyan",
+	FgHiWhite:    "fg-hi-white",
+	BgBlack:      "bg-black",
+	BgRed:        "bg-red",
+	BgGreen:      "bg-green",
+	BgYellow:     "bg-yellow",
+	BgBlue:       "bg-blue",
+	BgMagenta:    "bg-magenta",
+	BgCyan:       "bg-cyan",
+	BgWhite:      "bg-white",
+	BgHiBlack:    "bg-hi-black",
+	BgHiRed:      "bg-hi-red",
+	BgHiGreen:    "bg-hi-green",
+	BgHiYellow:   "bg-hi-yellow",
+	BgHiBlue:     "bg-hi-blue",
+	BgHiMagenta:  "bg-hi-magenta",
+	BgHiCyan:     "bg-hi-cyan",
+	BgHiWhite:    "bg-hi-white",
+}
diff --git a/text/escape.go b/text/escape.go
index d54e66e..abccef7 100644
--- a/text/escape.go
+++ b/text/escape.go
@@ -47,5 +47,4 @@ func (e *escSeq) InspectRune(r rune) {
 		}
 		e.content.WriteRune(r)
 	}
-	return
 }
diff --git a/text/transformer.go b/text/transformer.go
index 872d663..193a721 100644
--- a/text/transformer.go
+++ b/text/transformer.go
@@ -37,9 +37,9 @@ var (
 type Transformer func(val interface{}) string
 
 // NewNumberTransformer returns a number Transformer that:
-//   * transforms the number as directed by 'format' (ex.: %.2f)
-//   * colors negative values Red
-//   * colors positive values Green
+//   - transforms the number as directed by 'format' (ex.: %.2f)
+//   - colors negative values Red
+//   - colors positive values Green
 func NewNumberTransformer(format string) Transformer {
 	return func(val interface{}) string {
 		if valStr := transformInt(format, val); valStr != "" {
@@ -79,7 +79,7 @@ func transformInt(format string, val interface{}) string {
 		return transform(int64(number))
 	}
 	if number, ok := val.(int64); ok {
-		return transform(int64(number))
+		return transform(number)
 	}
 	return ""
 }
@@ -105,7 +105,7 @@ func transformUint(format string, val interface{}) string {
 		return transform(uint64(number))
 	}
 	if number, ok := val.(uint64); ok {
-		return transform(uint64(number))
+		return transform(number)
 	}
 	return ""
 }
@@ -125,7 +125,7 @@ func transformFloat(format string, val interface{}) string {
 		return transform(float64(number))
 	}
 	if number, ok := val.(float64); ok {
-		return transform(float64(number))
+		return transform(number)
 	}
 	return ""
 }
@@ -137,7 +137,7 @@ func NewJSONTransformer(prefix string, indent string) Transformer {
 		if valStr, ok := val.(string); ok {
 			var b bytes.Buffer
 			if err := json.Indent(&b, []byte(strings.TrimSpace(valStr)), prefix, indent); err == nil {
-				return string(b.Bytes())
+				return b.String()
 			}
 		} else if b, err := json.MarshalIndent(val, prefix, indent); err == nil {
 			return string(b)