167 lines
4.8 KiB
Go
167 lines
4.8 KiB
Go
package pterm
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// DefaultSection is the default section printer.
|
|
var DefaultSection = SectionPrinter{
|
|
Style: &ThemeDefault.SectionStyle,
|
|
Level: 1,
|
|
TopPadding: 1,
|
|
BottomPadding: 1,
|
|
IndentCharacter: "#",
|
|
}
|
|
|
|
// SectionPrinter prints a new section title.
|
|
// It can be used to structure longer text, or different chapters of your program.
|
|
type SectionPrinter struct {
|
|
Style *Style
|
|
Level int
|
|
IndentCharacter string
|
|
TopPadding int
|
|
BottomPadding int
|
|
}
|
|
|
|
// WithStyle returns a new SectionPrinter with a specific style.
|
|
func (p SectionPrinter) WithStyle(style *Style) *SectionPrinter {
|
|
p.Style = style
|
|
return &p
|
|
}
|
|
|
|
// WithLevel returns a new SectionPrinter with a specific level.
|
|
func (p SectionPrinter) WithLevel(level int) *SectionPrinter {
|
|
p.Level = level
|
|
return &p
|
|
}
|
|
|
|
// WithIndentCharacter returns a new SectionPrinter with a specific IndentCharacter.
|
|
func (p SectionPrinter) WithIndentCharacter(char string) *SectionPrinter {
|
|
p.IndentCharacter = char
|
|
return &p
|
|
}
|
|
|
|
// WithTopPadding returns a new SectionPrinter with a specific top padding.
|
|
func (p SectionPrinter) WithTopPadding(padding int) *SectionPrinter {
|
|
p.TopPadding = padding
|
|
return &p
|
|
}
|
|
|
|
// WithBottomPadding returns a new SectionPrinter with a specific top padding.
|
|
func (p SectionPrinter) WithBottomPadding(padding int) *SectionPrinter {
|
|
p.BottomPadding = padding
|
|
return &p
|
|
}
|
|
|
|
// 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 (p SectionPrinter) Sprint(a ...interface{}) string {
|
|
if p.Style == nil {
|
|
p.Style = NewStyle()
|
|
}
|
|
|
|
var ret string
|
|
|
|
for i := 0; i < p.TopPadding; i++ {
|
|
ret += "\n"
|
|
}
|
|
|
|
if p.Level > 0 {
|
|
ret += strings.Repeat(p.IndentCharacter, p.Level) + " "
|
|
}
|
|
|
|
ret += p.Style.Sprint(a...)
|
|
|
|
for i := 0; i < p.BottomPadding; i++ {
|
|
ret += "\n"
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
// 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 (p SectionPrinter) Sprintln(a ...interface{}) string {
|
|
str := fmt.Sprintln(a...)
|
|
return Sprint(p.Sprint(str))
|
|
}
|
|
|
|
// Sprintf formats according to a format specifier and returns the resulting string.
|
|
func (p SectionPrinter) Sprintf(format string, a ...interface{}) string {
|
|
return p.Sprint(Sprintf(format, a...))
|
|
}
|
|
|
|
// Sprintfln formats according to a format specifier and returns the resulting string.
|
|
// Spaces are always added between operands and a newline is appended.
|
|
func (p SectionPrinter) Sprintfln(format string, a ...interface{}) string {
|
|
return p.Sprintf(format, a...) + "\n"
|
|
}
|
|
|
|
// 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 (p *SectionPrinter) Print(a ...interface{}) *TextPrinter {
|
|
Print(p.Sprint(a...))
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|
|
|
|
// 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 (p *SectionPrinter) Println(a ...interface{}) *TextPrinter {
|
|
Print(p.Sprintln(a...))
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|
|
|
|
// 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 (p *SectionPrinter) Printf(format string, a ...interface{}) *TextPrinter {
|
|
Print(p.Sprintf(format, a...))
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|
|
|
|
// Printfln formats according to a format specifier 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 (p *SectionPrinter) Printfln(format string, a ...interface{}) *TextPrinter {
|
|
Print(p.Sprintfln(format, a...))
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|
|
|
|
// PrintOnError prints every error which is not nil.
|
|
// If every error is nil, nothing will be printed.
|
|
// This can be used for simple error checking.
|
|
func (p *SectionPrinter) PrintOnError(a ...interface{}) *TextPrinter {
|
|
for _, arg := range a {
|
|
if err, ok := arg.(error); ok {
|
|
if err != nil {
|
|
p.Println(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|
|
|
|
// PrintOnErrorf wraps every error which is not nil and prints it.
|
|
// If every error is nil, nothing will be printed.
|
|
// This can be used for simple error checking.
|
|
func (p *SectionPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter {
|
|
for _, arg := range a {
|
|
if err, ok := arg.(error); ok {
|
|
if err != nil {
|
|
p.Println(fmt.Errorf(format, err))
|
|
}
|
|
}
|
|
}
|
|
|
|
tp := TextPrinter(p)
|
|
return &tp
|
|
}
|