brimtext

func Align ¶

func Align(data [][]string, opts *AlignOptions) string

Align will format a table according to options. If opts is nil, NewDefaultAlignOptions is used.

package main

import (
	"fmt"

	"github.com/gholt/brimtext"
)

func main() {
	fmt.Println(brimtext.Align([][]string{
		{"", "Bob", "Sue", "John"},
		{"Hometown", "San Antonio", "Austin", "New York"},
		{"Mother", "Bessie", "Mary", "Sarah"},
		{"Father", "Rick", "Dan", "Mike"},
	}, nil))
}

Output:

         Bob         Sue    John
Hometown San Antonio Austin New York
Mother   Bessie      Mary   Sarah
Father   Rick        Dan    Mike

package main

import (
	"fmt"

	"github.com/gholt/brimtext"
)

func main() {
	fmt.Println(brimtext.Align([][]string{
		{"", "Bob", "Sue", "John"},
		nil,
		{"Hometown", "San Antonio", "Austin", "New York"},
		{"Mother", "Bessie", "Mary", "Sarah"},
		{"Father", "Rick", "Dan", "Mike"},
	}, brimtext.NewSimpleAlignOptions()))
}

Output:

+----------+-------------+--------+----------+
|          | Bob         | Sue    | John     |
+----------+-------------+--------+----------+
| Hometown | San Antonio | Austin | New York |
| Mother   | Bessie      | Mary   | Sarah    |
| Father   | Rick        | Dan    | Mike     |
+----------+-------------+--------+----------+

package main

import (
	"fmt"

	"github.com/gholt/brimtext"
)

func main() {
	data := [][]int{
		{8, 20, 11},
		{5, 11, 10},
		{3, 9, 1},
		{1200000, 2400000, 1700000},
	}
	table := [][]string{{"", "Bob", "Sue", "John"}}
	for rowNum, values := range data {
		row := []string{""}
		prefix := ""
		switch rowNum {
		case 0:
			row[0] = "Shot Attempts"
		case 1:
			row[0] = "Shots Made"
		case 2:
			row[0] = "Shots Missed"
		case 3:
			row[0] = "Salary"
			prefix = "$"
		}
		for _, v := range values {
			row = append(row, prefix+brimtext.ThousandsSep(int64(v), ","))
		}
		table = append(table, row)
	}
	opts := brimtext.NewUnicodeBoxedAlignOptions()
	opts.Alignments = []brimtext.Alignment{
		brimtext.Right,
		brimtext.Right,
		brimtext.Right,
		brimtext.Right,
	}
	fmt.Println(brimtext.Align(table, opts))
}

Output:

╔═══════════════╦════════════╤════════════╤════════════╗
║               ║        Bob │        Sue │       John ║
╠═══════════════╬════════════╪════════════╪════════════╣
║ Shot Attempts ║          8 │         20 │         11 ║
╟───────────────╫────────────┼────────────┼────────────╢
║    Shots Made ║          5 │         11 │         10 ║
╟───────────────╫────────────┼────────────┼────────────╢
║  Shots Missed ║          3 │          9 │          1 ║
╟───────────────╫────────────┼────────────┼────────────╢
║        Salary ║ $1,200,000 │ $2,400,000 │ $1,700,000 ║
╚═══════════════╩════════════╧════════════╧════════════╝

package main

import (
	"fmt"

	"github.com/gholt/brimtext"
)

func main() {
	opts := brimtext.NewUnicodeBoxedAlignOptions()
	opts.FirstFirstDLR = opts.FirstDLR
	opts.RowSecondUD = opts.RowUD
	opts.NilFirstUDLR = opts.NilUDLR
	opts.FirstNilFirstUDR = opts.NilFirstUDR
	opts.FirstNilLR = opts.NilLR
	opts.FirstNilFirstUDLR = opts.NilFirstUDLR
	opts.FirstNilUDLR = opts.NilUDLR
	opts.FirstNilLastUDL = opts.NilLastUDL
	opts.LastFirstULR = opts.LastULR
	opts.NilBetweenEveryRow = false
	opts.Alignments = []brimtext.Alignment{
		brimtext.Left,
		brimtext.Right,
		brimtext.Right,
	}
	fmt.Println(brimtext.Align([][]string{
		{"Name", "Points", "Assists"},
		nil,
		{"Bob", "10", "1"},
		{"Sue", "7", "5"},
		{"John", "2", "1"},
		nil,
		{"Shooting Stars", "19", "7"},
	}, opts))
}

Output:

╔════════════════╤════════╤═════════╗
║ Name           │ Points │ Assists ║
╟────────────────┼────────┼─────────╢
║ Bob            │     10 │       1 ║
║ Sue            │      7 │       5 ║
║ John           │      2 │       1 ║
╟────────────────┼────────┼─────────╢
║ Shooting Stars │     19 │       7 ║
╚════════════════╧════════╧═════════╝

func AllEqual ¶

func AllEqual(values ...string) bool

AllEqual returns true if all the values are equal strings; no strings, AllEqual() or AllEqual([]string{}...), are considered AllEqual.

func ClosestANSIForeground ¶

func ClosestANSIForeground(red int, green int, blue int) []byte

ClosestANSIForeground translates the RGB values to the closest ANSIEscape sequence for that foreground color.

func ClosestANSIForegroundString ¶

func ClosestANSIForegroundString(value string) []byte

ClosestANSIForegroundString translates the CSS-style color (e.g. "#ac8" "#ffee66") string to the closest ANSIEscape sequence for that foreground color.

func FalseString ¶

func FalseString(value string) bool

FalseString returns true if the string contains a recognized false value, such as "false", "False", "FALSE", "no", "off", etc. Yes, there is already strconv.ParseBool, but this function is often easier to work with since it just returns true or false instead of (bool, error) like ParseBool does. If you need to differentiate between true, false, and unknown, ParseBool should be your choice. Although I suppose you could use TrueString(s), FalseString(s), and !TrueString(s) && !FalseString(s).

func GetTTYWidth ¶

func GetTTYWidth() int

GetTTYWidth returns the width of the controlling TTY if it can or 80.

func HumanSize ¶

func HumanSize(v float64, u float64, s []string) string

HumanSize returns a more readable size format. Quick, "standard" implementations are HumanSize1000 and HumanSize1024, but this more generic function is provided so you can tweak the output a bit more.

Here are the implementations of the two standard functions, to get an idea of how you might wish to use HumanSize directly.

// HumanSize1000 returns a more readable size format, such as
// HumanSize1000(1234567) giving "1.23m".
// These are 1,000 unit based: 1k = 1000, 1m = 1000000, etc.
func HumanSize1000(v float64) string {
	return HumanSize(v, 1000, []string{"", "k", "m", "g", "t", "p", "e", "z", "y"})
}

// HumanSize1024 returns a more readable size format, such as
// HumanSize1024(1234567) giving "1.18M".
// These are 1,024 unit based: 1K = 1024, 1M = 1048576, etc.
func HumanSize1024(v float64) string {
	return HumanSize(v, 1024, []string{"", "K", "M", "G", "T", "P", "E", "Z", "Y"})
}

func HumanSize1000 ¶

func HumanSize1000(v float64) string

HumanSize1000 returns a more readable size format, such as HumanSize1000(1234567) giving "1.23m". These are 1,000 unit based: 1k = 1000, 1m = 1000000, etc.

func HumanSize1024 ¶

func HumanSize1024(v float64) string

HumanSize1024 returns a more readable size format, such as HumanSize1024(1234567) giving "1.18M". These are 1,024 unit based: 1K = 1024, 1M = 1048576, etc.

func OrdinalSuffix ¶

func OrdinalSuffix(number int) string

OrdinalSuffix returns "st", "nd", "rd", etc. for the number given (1st, 2nd, 3rd, etc.).

func RuneLenStripANSIEscapes ¶

func RuneLenStripANSIEscapes(v string) int

func Sentence ¶

func Sentence(value string) string

Sentence converts the value into a sentence, uppercasing the first character and ensuring the string ends with a period. Useful to output better looking error.Error() messages, which are all lower case with no trailing period by convention.

func StripANSIEscapes ¶

func StripANSIEscapes(v string) string

func ThousandsSep ¶

func ThousandsSep(v int64, sep string) string

ThousandsSep returns the number formatted using the separator at each thousands position, such as ThousandsSep(1234567, ",") giving 1,234,567.

func ThousandsSepU ¶

func ThousandsSepU(v uint64, sep string) string

ThousandsSepU returns the number formatted using the separator at each thousands position, such as ThousandsSepU(1234567, ",") giving 1,234,567.

func TrueString ¶

func TrueString(value string) bool

TrueString returns true if the string contains a recognized true value, such as "true", "True", "TRUE", "yes", "on", etc. Yes, there is already strconv.ParseBool, but this function is often easier to work with since it just returns true or false instead of (bool, error) like ParseBool does. If you need to differentiate between true, false, and unknown, ParseBool should be your choice. Although I suppose you could use TrueString(s), FalseString(s), and !TrueString(s) && !FalseString(s).

func Wrap ¶

func Wrap(text string, width int, indent1 string, indent2 string) string

Wrap wraps text for more readable output.

The width can be a positive int for a specific width, 0 for the default width (attempted to get from terminal, 79 otherwise), or a negative number for a width relative to the default.

The indent1 is the prefix for the first line.

The indent2 is the prefix for any second or subsequent lines.