pterm

package module
v0.4.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 7, 2020 License: MIT Imports: 10 Imported by: 2,510

README

:computer: PTerm | Pretty Terminal

A golang module to print pretty text

Latest Release Stars Forks Issues
Downloads
PTerm Documentation Dops

⚠ NOTICE

PTerm is currently under development. It is very likely that not all things will remain as they are at the moment. However, PTerm is still functional. The versioning of PTerm follows the SemVer guidelines. Breaking Changes are explicitly mentioned in the changelogs and the version will be increased accordingly. Everybody is welcome to improve PTerm, whether by making suggestions or pull requests. Thanks <3

If you want to wait for a stable release, make sure to star the project and follow it, to get notified when we release v1.0.0 (stable) 🚀

📦 Installation

To make PTerm available in your project, you can run the following command.
Make sure to run this command inside your project, when you're using go modules 😉

go get github.com/pterm/pterm

📝 Documentation

To view the official documentation of the latest release, you can go to the automatically generated page of pkg.go.dev This documentation is very technical and includes every method that can be used in PTerm.

For an easy start we recommend that you take a look at the examples section. Here you can see pretty much every feature of PTerm with its source code. The animations of the examples are automatically updated as soon as something changes in PTerm.

Have fun exploring this project 🚀

❤ Contributing

If you have found a bug or want to suggest a feature, you can do so here by opening a new issue.

If you want to contribute to the development of PTerm, you are very welcome to do so. Our contribution guidelines can be found here.

🧪 Examples

demo

Animation

SHOW SOURCE 
package main

import (
	"strconv"
	"strings"
	"time"

	"github.com/pterm/pterm"
)

var (
	pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
		"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
)

func main() {
	// Change this to time.Millisecond*200 to speed up the demo.
	// Useful when debugging.
	const second = time.Second

	pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Println(
		"PTDP - PTerm Demo Program")
	pterm.Info.Println("This animation was generated with the latest version of PTerm!" +
		"\nPTerm works on nearly every terminal and operating system." +
		"\nIt's super easy to use!" +
		"\nIf you want, you can customize everything :)" +
		"\nYou can see the code of this demo in the " + pterm.LightMagenta("./_examples/demo") + " directory." +
		"\n" +
		"\nThis demo was updated at: " + pterm.Green(time.Now().Format("02 Jan 2006 - 15:04:05 MST")))
	pterm.Println()

	introSpinner := pterm.DefaultSpinner.WithRemoveWhenDone(true).Start("Waiting for 15 seconds...")
	time.Sleep(second)
	for i := 14; i > 0; i-- {
		if i > 1 {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " seconds...")
		} else {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " second...")
		}
		time.Sleep(second)
	}
	introSpinner.Stop()

	clear()

	pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Println(
		"Pseudo Application created with PTerm")

	time.Sleep(second)

	setupSpinner := pterm.DefaultSpinner.Start("Fetching pseudo install list...")
	time.Sleep(second * 4)
	setupSpinner.Success()

	p := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Downloading stuff").Start()
	for i := 0; i < p.Total; i++ {
		p.Title = "Downloading " + pseudoProgramList[i]
		pterm.Success.Println("Downloading " + pseudoProgramList[i])
		p.Increment()
		time.Sleep(time.Millisecond * 500)
	}
	pterm.Success.Println("Downloaded all pseudo programs!")

	pterm.Println()
	pterm.Info.Println("Installing pseudo programs")

	p = pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
	for i := 0; i < p.Total; i++ {
		p.Title = "Installing " + pseudoProgramList[i]
		if pseudoProgramList[i] == "pseudo-minecraft" {
			pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
		} else {
			pterm.Success.Println("Installing " + pseudoProgramList[i])
			p.Increment()
		}
		time.Sleep(second)
	}
}

func clear() {
	print("\033[H\033[2J")
}

header

Animation

SHOW SOURCE 
package main

import "github.com/pterm/pterm"

func main() {
	pterm.DefaultHeader.Println("This is the default header!")
}

header-custom

Animation

SHOW SOURCE 
package main

import "github.com/pterm/pterm"

func main() {
	// All available options: https://pkg.go.dev/github.com/pterm/pterm#HeaderPrinter

	// Build on top of DefaultHeader
	pterm.DefaultHeader. // Use DefaultHeader as base
				WithMargin(15).                                    // Set Margin to 15
				WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)). // Set BackgroundStyle to Cyan
				WithTextStyle(pterm.NewStyle(pterm.FgBlack)).      // Set TextStyle to Black
				Println("This is a custom header!")                // Print header
	// Instead of printing the header you can set it to a variable.
	// You can then reuse your custom header.

	// Making a completely new HeaderPrinter
	newHeader := pterm.HeaderPrinter{
		TextStyle:       pterm.NewStyle(pterm.FgBlack),
		BackgroundStyle: pterm.NewStyle(pterm.BgRed),
		Margin:          20,
	}

	newHeader.Println("This is a custom header!")

}

override-default-printer

Animation

SHOW SOURCE 
package main

import "github.com/pterm/pterm"

func main() {
	pterm.Error.Println("This is the default Error")

	pterm.Error.Prefix = pterm.Prefix{
		Text:  "OVERRIDE",
		Style: pterm.Style{pterm.BgCyan, pterm.FgRed},
	}

	pterm.Error.Println("This is the default Error after the prefix was overridden")
}

print-with-color

Animation

SHOW SOURCE 
package main

import "github.com/pterm/pterm"

func main() {
	// Simple Println with different colored words.
	pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
	pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
}

progressbar

Animation

SHOW SOURCE 
package main

import (
	"strings"
	"time"

	"github.com/pterm/pterm"
)

var fakeInstallList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

var vki int

func main() {
	p := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()

	for i := 0; i < p.Total; i++ {
		p.Title = "Downloading " + fakeInstallList[vki]
		pterm.Success.Println("Downloading " + fakeInstallList[vki])
		vki++
		p.Increment()
		time.Sleep(time.Millisecond * 350)
	}

	pterm.Success.Println("Finished downloading!")

	time.Sleep(time.Second * 5)
}

section

Animation

SHOW SOURCE 
package main

import "github.com/pterm/pterm"

func main() {
	pterm.DefaultSection.Println("This is a section!")
	pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
	pterm.DefaultSection.Println("This is another section!")
	pterm.Info.Println("And this is\nmore placeholder text")
}

spinner

Animation

SHOW SOURCE 
package main

import (
	"time"

	"github.com/pterm/pterm"
)

func main() {
	spinnerSuccess := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerSuccess.Success()

	spinnerWarning := pterm.DefaultSpinner.Start("Doing something important... (will warn)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerWarning.Warning()

	spinnerFail := pterm.DefaultSpinner.Start("Doing something important... (will fail)")

	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something

	spinnerFail.Fail()

	spinnerLiveText := pterm.DefaultSpinner.Start("Doing a lot of stuff...")

	time.Sleep(time.Second * 2)

	spinnerLiveText.UpdateText("It's really much")

	time.Sleep(time.Second * 2)

	spinnerLiveText.UpdateText("We're nearly done!")

	time.Sleep(time.Second * 2)

	spinnerLiveText.Success("Finally!")
}

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Red is an alias for FgRed.Sprint.
	Red = FgRed.Sprint
	// Cyan is an alias for FgCyan.Sprint.
	Cyan = FgCyan.Sprint
	// Gray is an alias for FgGray.Sprint.
	Gray = FgGray.Sprint
	// Blue is an alias for FgBlue.Sprint.
	Blue = FgBlue.Sprint
	// Black is an alias for FgBlack.Sprint.
	Black = FgBlack.Sprint
	// Green is an alias for FgGreen.Sprint.
	Green = FgGreen.Sprint
	// White is an alias for FgWhite.Sprint.
	White = FgWhite.Sprint
	// Yellow is an alias for FgYellow.Sprint.
	Yellow = FgYellow.Sprint
	// Magenta is an alias for FgMagenta.Sprint.
	Magenta = FgMagenta.Sprint

	// Normal is an alias for FgDefault.Sprint.
	Normal = FgDefault.Sprint

	// LightRed is a shortcut for FgLightRed.Sprint.
	LightRed = FgLightRed.Sprint
	// LightCyan is a shortcut for FgLightCyan.Sprint.
	LightCyan = FgLightCyan.Sprint
	// LightBlue is a shortcut for FgLightBlue.Sprint.
	LightBlue = FgLightBlue.Sprint
	// LightGreen is a shortcut for FgLightGreen.Sprint.
	LightGreen = FgLightGreen.Sprint
	// LightWhite is a shortcut for FgLightWhite.Sprint.
	LightWhite = FgLightWhite.Sprint
	// LightYellow is a shortcut for FgLightYellow.Sprint.
	LightYellow = FgLightYellow.Sprint
	// LightMagenta is a shortcut for FgLightMagenta.Sprint.
	LightMagenta = FgLightMagenta.Sprint
)
View Source 
var (
	// Info returns a PrefixPrinter, which can be used to print text with an "info" Prefix.
	Info = PrefixPrinter{
		Prefix: Prefix{
			Text:  "INFO",
			Style: NewStyle(FgBlack, BgCyan),
		},
		MessageStyle: NewStyle(FgLightCyan),
	}

	// Warning returns a PrefixPrinter, which can be used to print text with a "warning" Prefix.
	Warning = PrefixPrinter{
		Prefix: Prefix{
			Text:  "WARNING",
			Style: NewStyle(FgBlack, BgYellow),
		},
		MessageStyle: NewStyle(FgYellow),
	}

	// Success returns a PrefixPrinter, which can be used to print text with a "success" Prefix.
	Success = PrefixPrinter{
		Prefix: Prefix{
			Text:  "SUCCESS",
			Style: NewStyle(FgBlack, BgGreen),
		},
		MessageStyle: NewStyle(FgGreen),
	}

	// Error returns a PrefixPrinter, which can be used to print text with an "error" Prefix.
	Error = PrefixPrinter{
		Prefix: Prefix{
			Text:  "ERROR",
			Style: NewStyle(FgBlack, BgLightRed),
		},
		MessageStyle: NewStyle(FgLightRed),
	}

	// Fatal returns a PrefixPrinter, which can be used to print text with an "fatal" Prefix.
	// NOTICE: Fatal terminates the application immediately!
	Fatal = PrefixPrinter{
		Prefix: Prefix{
			Text:  "FATAL",
			Style: NewStyle(FgBlack, BgLightRed),
		},
		MessageStyle: NewStyle(FgLightRed),
		Fatal:        true,
	}

	// Description returns a PrefixPrinter, which can be used to print text with a "description" Prefix.
	Description = PrefixPrinter{
		Prefix: Prefix{
			Text:  "Description",
			Style: Style{FgLightWhite, BgDarkGray},
		},
		MessageStyle: Style{FgLightWhite},
	}
)
View Source 
var ActiveProgressBars []*Progressbar

ActiveProgressBars contains all running progressbars. Generally, there should only be one active Progressbar at a time.

View Source 
var (
	// DefaultHeader returns the printer for a default header text.
	// Defaults to LightWhite, Bold Text and a Gray DefaultHeader background.
	DefaultHeader = HeaderPrinter{
		TextStyle:       Style{FgLightWhite, Bold},
		BackgroundStyle: Style{BgGray},
		Margin:          5,
	}
)
View Source 
var (
	// DefaultProgressbar is the default progressbar.
	DefaultProgressbar = Progressbar{
		Total:                     100,
		LineCharacter:             "█",
		LastCharacter:             "█",
		ElapsedTimeRoundingFactor: time.Second,
		BarStyle:                  Style{FgLightCyan},
		TitleStyle:                Style{FgCyan},
		ShowTitle:                 true,
		ShowCount:                 true,
		ShowPercentage:            true,
		ShowElapsedTime:           true,
		BarFiller:                 " ",
	}
)
View Source 
var DefaultSection = SectionPrinter{
	Style:      NewStyle(FgLightYellow, Underscore),
	Level:      1,
	TopPadding: 1,
}

DefaultSection is the default section printer.

View Source 
var DefaultSpinner = Spinner{
	Sequence:       []string{"▀ ", " ▀", " ▄", "▄ "},
	Style:          Style{FgLightCyan},
	Delay:          time.Millisecond * 200,
	MessageStyle:   Style{FgLightWhite},
	SuccessPrinter: Success,
	FailPrinter:    Error,
	WarningPrinter: Warning,
}

DefaultSpinner is the default spinner.

View Source 
var (
	// ErrTerminalSizeNotDetectable - the terminal size can not be detected and the fallback values are used.
	ErrTerminalSizeNotDetectable = errors.New("terminal size could not be detected - using fallback value")
)
View Source 
var FallbackTerminalHeight = 10

FallbackTerminalHeight is the value used for GetTerminalHeight, if the actual height can not be detected You can override that value if necessary.

View Source 
var FallbackTerminalWidth = 80

FallbackTerminalWidth is the value used for GetTerminalWidth, if the actual width can not be detected You can override that value if necessary.

View Source 
var (
	// GrayBoxStyle wraps text in a gray box.
	GrayBoxStyle = NewStyle(BgGray, FgLightWhite)
)

Functions

func Fprint added in v0.1.0 

func Fprint(writer io.Writer, a ...interface{})

Fprint formats using the default formats for its operands and writes to w. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func Fprintln added in v0.1.0 

func Fprintln(writer io.Writer, a ...interface{})

Fprintln formats using the default formats for its operands and writes to w. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Fprinto added in v0.1.0 

func Fprinto(w io.Writer, a ...interface{})

Fprinto prints Printo to a custom writer.

func GetTerminalHeight added in v0.1.0 

func GetTerminalHeight() int

GetTerminalHeight returns the terminal height of the active terminal.

func GetTerminalSize added in v0.1.0 

func GetTerminalSize() (width, height int, err error)

GetTerminalSize returns the width and the height of the active terminal.

func GetTerminalWidth added in v0.1.0 

func GetTerminalWidth() int

GetTerminalWidth returns the terminal width of the active terminal.

func Print 

func Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func Printf 

func Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func Println 

func Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Printo added in v0.1.0 

func Printo(a ...interface{})

Printo overrides the current line in a terminal. If the current line is empty, the text will be printed like with pterm.Print. To create a new line, which Example: pterm.Printo("Hello, World") time.Sleep(time.Second) pterm.Oprint("Hello, Earth!")

func RemoveColorFromString added in v0.4.0 

func RemoveColorFromString(a ...interface{}) string

RemoveColorFromString removes color codes from a string.

func SetDefaultOutput added in v0.3.1 

func SetDefaultOutput(w io.Writer)

SetDefaultOutput sets the default output of pterm.

func Sprint 

func Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func Sprintf 

func Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func Sprintln added in v0.2.0 

func Sprintln(a ...interface{}) string

Sprintln returns what Println would print to the terminal.

func Sprinto added in v0.2.3 

func Sprinto(a ...interface{}) string

Sprinto returns what Printo would print.

Types

type Color 

type Color uint8

Color is a number which will be used to color strings in the terminal. 

const (
	FgBlack Color = iota + 30
	FgRed
	FgGreen
	FgYellow
	FgBlue
	FgMagenta
	FgCyan
	FgWhite
	// FgDefault revert default FG.
	FgDefault Color = 39
)

Foreground colors. basic foreground colors 30 - 37. 

const (
	FgDarkGray Color = iota + 90
	FgLightRed
	FgLightGreen
	FgLightYellow
	FgLightBlue
	FgLightMagenta
	FgLightCyan
	FgLightWhite
	// FgGray is an alias of FgDarkGray.
	FgGray Color = 90
)

Extra foreground color 90 - 97. 

const (
	BgBlack Color = iota + 40
	BgRed
	BgGreen
	BgYellow // BgBrown like yellow
	BgBlue
	BgMagenta
	BgCyan
	BgWhite
	// BgDefault reverts to the default background.
	BgDefault Color = 49
)

Background colors. basic background colors 40 - 47. 

const (
	BgDarkGray Color = iota + 100
	BgLightRed
	BgLightGreen
	BgLightYellow
	BgLightBlue
	BgLightMagenta
	BgLightCyan
	BgLightWhite
	// BgGray is an alias of BgDarkGray.
	BgGray Color = 100
)

Extra background color 100 - 107. 

const (
	Reset Color = iota
	Bold
	Fuzzy
	Italic
	Underscore
	Blink
	FastBlink
	Reverse
	Concealed
	Strikethrough
)

Option settings.

func (Color) Print 

func (c Color) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Printf 

func (c Color) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Println 

func (c Color) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Sprint 

func (c Color) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Color.

func (Color) Sprintf 

func (c Color) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Color.

func (Color) Sprintln 

func (c Color) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Color.

func (Color) String 

func (c Color) String() string

String converts the color to a string. eg "35".

type GenericPrinter 

type GenericPrinter interface {
	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	Sprint(a ...interface{}) string

	// Sprintln formats using the default formats for its operands and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	Sprintln(a ...interface{}) string

	// Sprintf formats according to a format specifier and returns the resulting string.
	Sprintf(format string, a ...interface{}) string

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Print(a ...interface{}) GenericPrinter

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Println(a ...interface{}) GenericPrinter

	// Printf formats according to a format specifier and writes to standard output.
	// It returns the number of bytes written and any write error encountered.
	Printf(format string, a ...interface{}) GenericPrinter
}

GenericPrinter contains methods to print formatted text to the console or return it as a string.

type HeaderPrinter added in v0.0.1 

type HeaderPrinter struct {
	TextStyle       Style
	BackgroundStyle Style
	Margin          int
	FullWidth       bool
}

HeaderPrinter contains the data used to craft a header. A header is printed as a big box with text in it. Can be used as title screens or section separator.

func (HeaderPrinter) Print added in v0.0.1 

func (p HeaderPrinter) Print(a ...interface{}) GenericPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Printf added in v0.0.1 

func (p HeaderPrinter) Printf(format string, a ...interface{}) GenericPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Println added in v0.0.1 

func (p HeaderPrinter) Println(a ...interface{}) GenericPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Sprint added in v0.0.1 

func (p HeaderPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (HeaderPrinter) Sprintf added in v0.0.1 

func (p HeaderPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (HeaderPrinter) Sprintln added in v0.0.1 

func (p HeaderPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (HeaderPrinter) WithBackgroundStyle added in v0.1.0 

func (p HeaderPrinter) WithBackgroundStyle(style Style) *HeaderPrinter

WithBackgroundStyle changes the background styling of the header.

func (HeaderPrinter) WithFullWidth added in v0.1.0 

func (p HeaderPrinter) WithFullWidth(b ...bool) *HeaderPrinter

WithFullWidth enables full width on a HeaderPrinter.

func (HeaderPrinter) WithMargin added in v0.1.0 

func (p HeaderPrinter) WithMargin(margin int) *HeaderPrinter

WithMargin changes the background styling of the header.

func (HeaderPrinter) WithTextStyle added in v0.1.0 

func (p HeaderPrinter) WithTextStyle(style Style) *HeaderPrinter

WithTextStyle returns a new HeaderPrinter with changed

type Prefix 

type Prefix struct {
	Text  string
	Style Style
}

Prefix contains the data used as the beginning of a printed text via a PrefixPrinter.

type PrefixPrinter 

type PrefixPrinter struct {
	Prefix       Prefix
	Scope        Scope
	MessageStyle Style
	Fatal        bool
}

PrefixPrinter is the printer used to print a Prefix.

func (PrefixPrinter) GetFormattedPrefix 

func (p PrefixPrinter) GetFormattedPrefix() string

GetFormattedPrefix returns the Prefix as a styled text string.

func (PrefixPrinter) Print 

func (p PrefixPrinter) Print(a ...interface{}) GenericPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Printf 

func (p PrefixPrinter) Printf(format string, a ...interface{}) GenericPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Println 

func (p PrefixPrinter) Println(a ...interface{}) GenericPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (PrefixPrinter) Sprint 

func (p PrefixPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (PrefixPrinter) Sprintf 

func (p PrefixPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (PrefixPrinter) Sprintln 

func (p PrefixPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (PrefixPrinter) WithFatal added in v0.3.0 

func (p PrefixPrinter) WithFatal(b ...bool) *PrefixPrinter

WithFatal sets if the printer should panic after printing. NOTE: The printer will only panic if either PrefixPrinter.Println, PrefixPrinter.Print or PrefixPrinter.Printf is called.

func (PrefixPrinter) WithMessageStyle added in v0.1.0 

func (p PrefixPrinter) WithMessageStyle(style Style) *PrefixPrinter

WithMessageStyle adds a custom prefix to the printer.

func (PrefixPrinter) WithPrefix added in v0.1.0 

func (p PrefixPrinter) WithPrefix(prefix Prefix) *PrefixPrinter

WithPrefix adds a custom prefix to the printer.

func (PrefixPrinter) WithScope 

func (p PrefixPrinter) WithScope(scope Scope) *PrefixPrinter

WithScope adds a scope to the Prefix.

type Progressbar added in v0.2.1 

type Progressbar struct {
	Title                     string
	Total                     int
	Current                   int
	UpdateDelay               time.Duration
	LineCharacter             string
	LastCharacter             string
	ElapsedTimeRoundingFactor time.Duration
	BarFiller                 string

	ShowElapsedTime bool
	ShowCount       bool
	ShowTitle       bool
	ShowPercentage  bool

	TitleStyle Style
	BarStyle   Style

	IsActive bool
	// contains filtered or unexported fields
}

Progressbar shows a progress animation in the terminal.

func (*Progressbar) Add added in v0.2.1 

func (p *Progressbar) Add(count int) *Progressbar

Add to current value.

func (*Progressbar) GetElapsedTime added in v0.2.1 

func (p *Progressbar) GetElapsedTime() time.Duration

GetElapsedTime returns the elapsed time, since the progressbar was started.

func (*Progressbar) Increment added in v0.2.1 

func (p *Progressbar) Increment() *Progressbar

Increment current value by one.

func (Progressbar) Start added in v0.2.1 

func (p Progressbar) Start() *Progressbar

Start the progressbar.

func (*Progressbar) Stop added in v0.2.1 

func (p *Progressbar) Stop() *Progressbar

Stop the progressbar.

func (Progressbar) WithBarStyle added in v0.3.0 

func (p Progressbar) WithBarStyle(style Style) *Progressbar

WithBarStyle sets the style of the bar.

func (Progressbar) WithCurrent added in v0.3.0 

func (p Progressbar) WithCurrent(current int) *Progressbar

WithCurrent sets the current value of the progressbar.

func (Progressbar) WithElapsedTimeRoundingFactor added in v0.3.0 

func (p Progressbar) WithElapsedTimeRoundingFactor(duration time.Duration) *Progressbar

WithElapsedTimeRoundingFactor sets the rounding factor of the elapsed time.

func (Progressbar) WithLastCharacter added in v0.3.0 

func (p Progressbar) WithLastCharacter(char string) *Progressbar

WithLastCharacter sets the last character of the progressbar.

func (Progressbar) WithLineCharacter added in v0.3.0 

func (p Progressbar) WithLineCharacter(char string) *Progressbar

WithLineCharacter sets the line character of the progressbar.

func (Progressbar) WithShowCount added in v0.3.0 

func (p Progressbar) WithShowCount(b ...bool) *Progressbar

WithShowCount sets if the total and current count should be displayed in the progressbar.

func (Progressbar) WithShowElapsedTime added in v0.3.0 

func (p Progressbar) WithShowElapsedTime(b ...bool) *Progressbar

WithShowElapsedTime sets if the elapsed time should be displayed in the progressbar.

func (Progressbar) WithShowPercentage added in v0.3.0 

func (p Progressbar) WithShowPercentage(b ...bool) *Progressbar

WithShowPercentage sets if the completed percentage should be displayed in the progressbar.

func (Progressbar) WithShowTitle added in v0.3.0 

func (p Progressbar) WithShowTitle(b ...bool) *Progressbar

WithShowTitle sets if the title should be displayed in the progressbar.

func (Progressbar) WithTitle added in v0.3.0 

func (p Progressbar) WithTitle(name string) *Progressbar

WithTitle sets the name of the progressbar.

func (Progressbar) WithTitleStyle added in v0.3.0 

func (p Progressbar) WithTitleStyle(style Style) *Progressbar

WithTitleStyle sets the style of the title.

func (Progressbar) WithTotal added in v0.3.0 

func (p Progressbar) WithTotal(total int) *Progressbar

WithTotal sets the total value of the progressbar.

func (Progressbar) WithUpdateDelay added in v0.3.0 

func (p Progressbar) WithUpdateDelay(delay time.Duration) *Progressbar

WithUpdateDelay sets the update delay of the progressbar.

type Scope 

type Scope struct {
	Text  string
	Style Style
}

Scope contains the data of the optional scope of a prefix. If it has a text, it will be printed after the Prefix in brackets.

type SectionPrinter added in v0.3.2 

type SectionPrinter struct {
	Style      Style
	Level      int
	TopPadding int
}

SectionPrinter can print errors of the default Error type.

func (SectionPrinter) Print added in v0.3.2 

func (p SectionPrinter) Print(a ...interface{}) GenericPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (SectionPrinter) Printf added in v0.3.2 

func (p SectionPrinter) Printf(format string, a ...interface{}) GenericPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (SectionPrinter) Println added in v0.3.2 

func (p SectionPrinter) Println(a ...interface{}) GenericPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (SectionPrinter) Sprint added in v0.3.2 

func (p SectionPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (SectionPrinter) Sprintf added in v0.3.2 

func (p SectionPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (SectionPrinter) Sprintln added in v0.3.2 

func (p SectionPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (SectionPrinter) WithLevel added in v0.4.0 

func (p SectionPrinter) WithLevel(level int) *SectionPrinter

WithLevel returns a new SectionPrinter with a specific level.

func (SectionPrinter) WithStyle added in v0.4.0 

func (p SectionPrinter) WithStyle(style Style) *SectionPrinter

WithStyle returns a new SectionPrinter with a specific style.

func (SectionPrinter) WithTopPadding added in v0.4.0 

func (p SectionPrinter) WithTopPadding(level int) *SectionPrinter

WithTopPadding returns a new SectionPrinter with a specific top padding.

type Spinner added in v0.1.0 

type Spinner struct {
	Text           string
	Sequence       []string
	Style          Style
	Delay          time.Duration
	MessageStyle   Style
	SuccessPrinter GenericPrinter
	FailPrinter    GenericPrinter
	WarningPrinter GenericPrinter
	RemoveWhenDone bool

	IsActive bool
}

Spinner is a loading animation, which can be used if the progress is unknown. It's an animation loop, which can have a text and supports throwing errors or warnings. A GenericPrinter is used to display all outputs, after the spinner is done.

func (*Spinner) Fail added in v0.1.0 

func (s *Spinner) Fail(message ...interface{})

Fail displays the fail printer. If no message is given, the text of the spinner will be reused as the default message.

func (Spinner) Start added in v0.1.0 

func (s Spinner) Start(text ...interface{}) *Spinner

Start starts the spinner.

func (*Spinner) Stop added in v0.1.0 

func (s *Spinner) Stop()

Stop terminates the Spinner immediately. The Spinner will not resolve into anything.

func (*Spinner) Success added in v0.1.0 

func (s *Spinner) Success(message ...interface{})

Success displays the success printer. If no message is given, the text of the spinner will be reused as the default message.

func (*Spinner) UpdateText added in v0.2.0 

func (s *Spinner) UpdateText(text string)

UpdateText updates the message of the active spinner. Can be used live.

func (*Spinner) Warning added in v0.1.0 

func (s *Spinner) Warning(message ...interface{})

Warning displays the warning printer. If no message is given, the text of the spinner will be reused as the default message.

func (Spinner) WithDelay added in v0.1.0 

func (s Spinner) WithDelay(delay time.Duration) *Spinner

WithDelay adds a delay to the spinner.

func (Spinner) WithMessageStyle added in v0.1.0 

func (s Spinner) WithMessageStyle(style Style) *Spinner

WithMessageStyle adds a style to the spinner message.

func (Spinner) WithRemoveWhenDone added in v0.3.0 

func (s Spinner) WithRemoveWhenDone(b ...bool) *Spinner

WithRemoveWhenDone removes the spinner after it is done.

func (Spinner) WithSequence added in v0.1.0 

func (s Spinner) WithSequence(sequence ...string) *Spinner

WithSequence adds a sequence to the spinner.

func (Spinner) WithStyle added in v0.1.0 

func (s Spinner) WithStyle(style Style) *Spinner

WithStyle adds a style to the spinner.

func (Spinner) WithText added in v0.1.0 

func (s Spinner) WithText(text string) *Spinner

WithText adds a text to the spinner.

type Style 

type Style []Color

Style is a collection of colors. Can include foreground, background and styling (eg. Bold, Underscore, etc.) colors.

func NewStyle added in v0.0.1 

func NewStyle(colors ...Color) Style

NewStyle returns a new Style. Accepts multiple colors.

func (Style) Add added in v0.4.0 

func (s Style) Add(styles ...Style) Style

Add styles to the current Style.

func (Style) Code 

func (s Style) Code() string

Code convert to code string. returns like "32;45;3".

func (Style) Print 

func (s Style) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Printf 

func (s Style) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Println 

func (s Style) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Sprint 

func (s Style) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Style.

func (Style) Sprintf 

func (s Style) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Style.

func (Style) Sprintln 

func (s Style) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Style.

func (Style) String 

func (s Style) String() string

String convert to code string. returns like "32;45;3".

Source Files

View all Source files

Directories

Path Synopsis
_examples
demo command
header command
header-custom command
override-default-printer command
print-with-color command
progressbar command
section command
spinner command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.