satisfy full linter

pkg/printer/table.go

@@ -55,6 +55,7 @@ func NewTable(conf *cfg.Config, columns, rows int) *Table {
 func NewTableEmpty(conf *cfg.Config) *Table {
 	table := Table{Mode: conf.Output, maxwidth: cfg.GetTermWidth()}
 	table.alignInts = conf.AlignInts
+
 	return &table
 }
 
@@ -70,14 +71,14 @@ func (table *Table) WithHeaders(headers ...string) *Table {
 	return table
 }
 
-func (data *Table) Print() error {
-	switch data.Mode {
+func (table *Table) Print() error {
+	switch table.Mode {
 	case "json":
-		return data.PrintJSON()
+		return table.PrintJSON()
 	case "yaml":
-		return data.PrintYAML()
+		return table.PrintYAML()
 	default:
-		return data.PrintTSV()
+		return table.PrintTSV()
 	}
 }
 
@@ -85,22 +86,8 @@ var (
 	ansiCtrlSeq = regexp.MustCompile(`\033.[0-9;]+m`)
 )
 
-// needed for json and yaml output
-func (data *Table) toMap() []map[string]any {
-	raw := make([]map[string]any, len(data.Entries))
-
-	for idx, entries := range data.Entries {
-		raw[idx] = make(map[string]any, len(data.Headers))
-		for eidx, entry := range entries {
-			raw[idx][data.Headers[eidx]] = entry
-		}
-	}
-
-	return raw
-}
-
-func (data *Table) PrintYAML() error {
-	raw := data.toMap()
+func (table *Table) PrintYAML() error {
+	raw := table.toMap()
 
 	body, err := yaml.Marshal(raw)
 	if err != nil {
@@ -112,8 +99,8 @@ func (data *Table) PrintYAML() error {
 	return nil
 }
 
-func (data *Table) PrintJSON() error {
-	raw := data.toMap()
+func (table *Table) PrintJSON() error {
+	raw := table.toMap()
 
 	body, err := json.MarshalIndent(raw, "", "  ")
 	if err != nil {
@@ -125,34 +112,35 @@ func (data *Table) PrintJSON() error {
 	return nil
 }
 
-func (data *Table) PrintTSV() error {
+func (table *Table) PrintTSV() error {
 	// length's, convert cell types
-	data.preprocessRows()
+	table.preprocessRows()
 
 	// output headers
-	for idx, header := range data.Headers {
-		if idx+1 != len(data.Headers) {
-			fmt.Print(header, strings.Repeat(" ", data.lenHeaders[idx]-visibleLen(header)))
+	for idx, header := range table.Headers {
+		if idx+1 != len(table.Headers) {
+			fmt.Print(header, strings.Repeat(" ", table.lenHeaders[idx]-visibleLen(header)))
 		} else {
 			// no padding for last header
 			fmt.Print(header)
 		}
 
-		if idx < len(data.Headers)-1 {
+		if idx < len(table.Headers)-1 {
 			fmt.Print("  ")
 		}
 	}
+
 	fmt.Println()
 
-	for _, entries := range data.rows {
+	for _, entries := range table.rows {
 		currentWidth := 0
 
 		for idx, entry := range entries {
 			length := visibleLen(entry)
 
-			if length+currentWidth > data.maxwidth && data.maxwidth-currentWidth > 1 {
+			if length+currentWidth > table.maxwidth && table.maxwidth-currentWidth > 1 {
 				// text is too wide to be put into one line, wrap it
-				wrapper := wordwrap.Wrapper(data.maxwidth-currentWidth, false)
+				wrapper := wordwrap.Wrapper(table.maxwidth-currentWidth, false)
 				wrapped := wrapper(entry)
 
 				// and indent it
@@ -165,55 +153,71 @@ func (data *Table) PrintTSV() error {
 				}
 			}
 
-			currentWidth += data.lenHeaders[idx]
+			currentWidth += table.lenHeaders[idx]
 
-			if isInt(entry) && data.alignInts {
+			switch {
+			case isInt(entry) && table.alignInts:
 				// align right
-				fmt.Print(strings.Repeat(" ", data.lenHeaders[idx]-length), entry)
-			} else if length < data.lenHeaders[idx] && idx+1 != len(entries) {
+				fmt.Print(strings.Repeat(" ", table.lenHeaders[idx]-length), entry)
+			case length < table.lenHeaders[idx] && idx+1 != len(entries):
 				// pad right, if required
-				fmt.Print(entry, strings.Repeat(" ", data.lenHeaders[idx]-length))
-			} else {
+				fmt.Print(entry, strings.Repeat(" ", table.lenHeaders[idx]-length))
+			default:
 				// no padding for last entry
 				fmt.Print(entry)
 			}
 
-			if idx < len(data.Headers)-1 {
+			if idx < len(table.Headers)-1 {
 				fmt.Print("  ")
 			}
 		}
+
 		fmt.Println()
 	}
 
 	return nil
 }
 
-func (data *Table) Sort() {
+func (table *Table) Sort() {
 	// sanity checks
-	if len(data.Entries) == 0 {
+	if len(table.Entries) == 0 {
 		return
 	}
 
-	data.preprocessRows()
+	table.preprocessRows()
 
-	sort.Slice(data.rows, func(i, j int) bool {
-		return data.rows[i][0] < data.rows[j][0]
+	sort.Slice(table.rows, func(i, j int) bool {
+		return table.rows[i][0] < table.rows[j][0]
 	})
 }
 
-func (data *Table) Addheaders(headers ...string) {
+func (table *Table) Addheaders(headers ...string) {
 	for idx, header := range headers {
-		switch data.Mode {
+		switch table.Mode {
 		case "json", "yaml":
-			data.Headers[idx] = strings.ReplaceAll(strings.ToLower(header), " ", "_")
+			table.Headers[idx] = strings.ReplaceAll(strings.ToLower(header), " ", "_")
 		default:
-			data.Headers[idx] = bold(strings.ReplaceAll(strings.ToUpper(header), " ", "-"))
+			table.Headers[idx] = bold(strings.ReplaceAll(strings.ToUpper(header), " ", "-"))
 		}
 	}
 }
 
-func (data *Table) AddRow(fields ...any) {
-	data.Entries = append(data.Entries, fields)
+func (table *Table) AddRow(fields ...any) {
+	table.Entries = append(table.Entries, fields)
+}
+
+// needed for json and yaml output
+func (table *Table) toMap() []map[string]any {
+	raw := make([]map[string]any, len(table.Entries))
+
+	for idx, entries := range table.Entries {
+		raw[idx] = make(map[string]any, len(table.Headers))
+		for eidx, entry := range entries {
+			raw[idx][table.Headers[eidx]] = entry
+		}
+	}
+
+	return raw
 }
 
 // return the length of a string but only visible chars, w/o ansi color escapes