pax_global_header 0000666 0000000 0000000 00000000064 14650106263 0014515 g ustar 00root root 0000000 0000000 52 comment=8b37d4ece5d980a9e00d9b70a287eda2d714be05
golang-github-pterm-pterm-0.12.79/ 0000775 0000000 0000000 00000000000 14650106263 0016676 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/.github/ 0000775 0000000 0000000 00000000000 14650106263 0020236 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/.github/CODEOWNERS 0000664 0000000 0000000 00000000026 14650106263 0021627 0 ustar 00root root 0000000 0000000 * @MarvinJWendt
golang-github-pterm-pterm-0.12.79/.github/FUNDING.yml 0000664 0000000 0000000 00000001365 14650106263 0022060 0 ustar 00root root 0000000 0000000 # These are supported funding model platforms
github: [ MarvinJWendt ] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: ['https://marvin.ws/donate'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
golang-github-pterm-pterm-0.12.79/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14650106263 0022421 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000000163 14650106263 0025113 0 ustar 00root root 0000000 0000000 ---
name: Bug report
about: 🐞 Create a bug report to help us improve
title: ''
labels: bug
assignees: ''
---
golang-github-pterm-pterm-0.12.79/.github/ISSUE_TEMPLATE/config.yml 0000664 0000000 0000000 00000000242 14650106263 0024407 0 ustar 00root root 0000000 0000000 contact_links:
- name: Twitter
url: https://marvin.ws/twitter
about: 💬 For questions, feedback and support, you can contact me directly via Twitter!
golang-github-pterm-pterm-0.12.79/.github/ISSUE_TEMPLATE/feature_request.md 0000664 0000000 0000000 00000000170 14650106263 0026144 0 ustar 00root root 0000000 0000000 ---
name: Feature request
about: "✨ Suggest an idea for this project"
title: ''
labels: proposal
assignees: ''
---
golang-github-pterm-pterm-0.12.79/.github/dependabot.yml 0000664 0000000 0000000 00000000767 14650106263 0023100 0 ustar 00root root 0000000 0000000 # To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
version: 2
updates:
- package-ecosystem: "gomod" # See documentation for possible values
directory: "/" # Location of package manifests
schedule:
interval: "daily"
golang-github-pterm-pterm-0.12.79/.github/pull_request_template.md 0000664 0000000 0000000 00000000162 14650106263 0025176 0 ustar 00root root 0000000 0000000
Fixes #YOUR_ISSUE_NUMBER
golang-github-pterm-pterm-0.12.79/.github/release.yml 0000664 0000000 0000000 00000000537 14650106263 0022406 0 ustar 00root root 0000000 0000000 changelog:
exclude:
labels:
- ignore-for-release
authors:
- octocat
categories:
- title: Breaking Changes 🛠
labels:
- breaking
- title: Exciting New Features 🎉
labels:
- feature
- title: Fixes 🔧
labels:
- fix
- title: Other Changes
labels:
- "*"
golang-github-pterm-pterm-0.12.79/.github/workflows/ 0000775 0000000 0000000 00000000000 14650106263 0022273 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/.github/workflows/animator.yml 0000664 0000000 0000000 00000000670 14650106263 0024633 0 ustar 00root root 0000000 0000000 on:
push:
branches: master
name: Update Animations
jobs:
animator:
if: "!contains(github.event.head_commit.message, 'autoupdate')"
runs-on: ubuntu-latest
steps:
- name: Git Setup
run: git config --global --add safe.directory /github/workspace
- name: Update Docs
uses: pterm/animation-ci@master
env:
ACCESS_TOKEN: ${{ secrets.ACCESS_TOKEN }}
TERM: xterm-256color
golang-github-pterm-pterm-0.12.79/.github/workflows/conventional-label.yaml 0000664 0000000 0000000 00000000302 14650106263 0026726 0 ustar 00root root 0000000 0000000 on:
pull_request_target:
types: [ opened, edited ]
name: conventional-release-labels
jobs:
label:
runs-on: ubuntu-latest
steps:
- uses: bcoe/conventional-release-labels@v1
golang-github-pterm-pterm-0.12.79/.github/workflows/go.yml 0000664 0000000 0000000 00000001570 14650106263 0023426 0 ustar 00root root 0000000 0000000 name: Go
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
build:
if: "!contains(github.event.head_commit.message, 'autoupdate')"
name: Build
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ windows-latest ]
steps:
- name: Set up Go 1.x
uses: actions/setup-go@v4
with:
go-version: 1.21
cache-dependency-path: go.sum
id: go
- name: Check out code into the Go module directory
uses: actions/checkout@v3
- name: Get dependencies
run: go get -v -t -d ./...
- name: Build
run: go build -v .
- name: Test
run: go test -coverprofile="coverage.txt" -covermode=atomic -p 1 .
- name: Upload coverage to Codecov
if: success() && matrix.os == 'windows-latest'
uses: codecov/codecov-action@v3
golang-github-pterm-pterm-0.12.79/.github/workflows/lint.yml 0000664 0000000 0000000 00000000647 14650106263 0023773 0 ustar 00root root 0000000 0000000 name: Code Analysis
on: [ push, pull_request ]
jobs:
lint:
if: "!contains(github.event.head_commit.message, 'autoupdate')"
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Go
uses: actions/setup-go@v4
with:
go-version: 'stable'
- name: golangci-lint
uses: golangci/golangci-lint-action@v3
with:
version: latest
golang-github-pterm-pterm-0.12.79/.gitignore 0000664 0000000 0000000 00000000526 14650106263 0020671 0 ustar 00root root 0000000 0000000 # Binaries for programs and plugins
*.exe
*.exe~
*.dll
*.so
*.dylib
# Test binary, built with `go test -c`
*.test
# Output of the go coverage tool, specifically when used with LiteIDE
*.out
# Dependency directories (remove the comment below to include it)
vendor/
# This is where we test stuff
/experimenting/*
/.history
/.vscode
/.idea
golang-github-pterm-pterm-0.12.79/.golangci.yml 0000664 0000000 0000000 00000003472 14650106263 0021270 0 ustar 00root root 0000000 0000000 linters-settings:
gocritic:
enabled-tags:
- diagnostic
- experimental
- opinionated
- performance
- style
disabled-checks:
- dupImport
- ifElseChain
- octalLiteral
- whyNoLint
- wrapperFunc
- exitAfterDefer
- hugeParam
- ptrToRefParam
- paramTypeCombine
- unnamedResult
# maligned:
# suggest-new: true
misspell:
locale: US
linters:
disable-all: true
enable:
- gocritic
- gosec
- govet
- ineffassign
- unconvert
- gosimple
- godox
- whitespace
- staticcheck
# - bodyclose
# - maligned
# - godot
# - deadcode
# - depguard
# - dogsled
# - dupl
# - errcheck
# - exhaustive
# - funlen
# - gochecknoinits
# - goconst
# - gocyclo
# - gofmt
# - goimports
# - golint
# - gomnd
# - goprintffuncname
# - lll
# - misspell
# - nakedret
# - noctx
# - nolintlint
# - rowserrcheck
# - scopelint
# - structcheck
# - stylecheck
# - typecheck
# - unparam
# - unused
# - varcheck
# - whitespace
# - asciicheck
# - gochecknoglobals
# - gocognit
# - goerr113
# - nestif
# - prealloc
# - testpackage
# - wsl
issues:
# Excluding configuration per-path, per-linter, per-text and per-source
exclude-rules:
- path: _test\.go
linters:
- gocyclo
- errcheck
- dupl
- gosec
- gocritic
# https://github.com/go-critic/go-critic/issues/926
- linters:
- gocritic
text: "unnecessaryDefer:"
- linters:
- gocritic
text: "preferDecodeRune:"
service:
golangci-lint-version: 1.31.x # use the fixed version to not introduce new linters unexpectedly
golang-github-pterm-pterm-0.12.79/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000006432 14650106263 0021502 0 ustar 00root root 0000000 0000000 # Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, sex characteristics, gender identity and expression,
level of experience, education, socio-economic status, nationality, personal
appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at pterm@marvinjwendt.com. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see
https://www.contributor-covenant.org/faq
golang-github-pterm-pterm-0.12.79/CONTRIBUTING.md 0000664 0000000 0000000 00000013607 14650106263 0021136 0 ustar 00root root 0000000 0000000 # Contributing to PTerm
> This document explains how to participate in the development of PTerm.\
If your goal is to report a bug instead of programming PTerm, you can do so [here](https://github.com/pterm/pterm/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc).
## Best practise
We enforce some best practises, especially made for PTerm, to provide a clean and consistent user experience.
### Styles
Styles should always be consumed as pointers. That way, the user can change the style of printers globally.
## Creating a new printer
> In this chapter we will show you how to create a new printer.
### `TextPrinter` Template
```go
package pterm
type TemplatePrinter struct{
// TODO: Add printer settings here
}
// 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 TemplatePrinter) Sprint(a ...interface{}) string {
panic("write printer code here")
}
// 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 TemplatePrinter) Sprintln(a ...interface{}) string {
return Sprintln(p.Sprint(a...))
}
// Sprintf formats according to a format specifier and returns the resulting string.
func (p TemplatePrinter) Sprintf(format string, a ...interface{}) string {
return p.Sprint(Sprintf(format, a...))
}
// 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 TemplatePrinter) 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 TemplatePrinter) Println(a ...interface{}) *TextPrinter {
Println(p.Sprint(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 TemplatePrinter) Printf(format string, a ...interface{}) *TextPrinter {
Print(p.Sprintf(format, a...))
tp := TextPrinter(p)
return &tp
}
```
### `RenderablePrinter` Template
```go
package pterm
type TemplatePrinter struct{
// TODO: Add printer settings here
}
// Srender renders the Template as a string.
func (p TemplatePrinter) Srender() (string, error) {
var ret string
return ret, nil
}
// Render prints the Template to the terminal.
func (p TemplatePrinter) Render() error {
s, err := p.Srender()
if err != nil {
return err
}
Println(s)
return nil
}
```
### `LivePrinter` Template
```go
// Start the TemplatePrinter.
package pterm
import "github.com/pterm/pterm"
type TemplatePrinter struct{
}
func (s TemplatePrinter) Start(text...interface{}) (*TemplatePrinter, error) { // TODO: Replace Template with actual printer.
// TODO: start logic
return &s, nil
}
// Stop terminates the TemplatePrinter immediately.
// The TemplatePrinter will not resolve into anything.
func (s *TemplatePrinter) Stop() error {
// TODO: stop logic
return nil
}
// GenericStart runs Start, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Start instead of this in your program.
func (s *TemplatePrinter) GenericStart() (*LivePrinter, error) {
_, err := s.Start()
lp := LivePrinter(s)
return &lp, err
}
// GenericStop runs Stop, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Stop instead of this in your program.
func (s *TemplatePrinter) GenericStop() (*LivePrinter, error) {
err := s.Stop()
lp := LivePrinter(s)
return &lp, err
}
```
## Writing Tests
> Each method of PTerm must be tested.
### Required tests for every printer
#### Nil Check
> This ensures that a printer without set values will not produce errors.
```go
func TestTemplatePrinterNilPrint(t *testing.T) { // TODO: Replace "Template" with actual printer name.
p := TemplatePrinter{} // TODO: Replace "Template" with actual printer name.
p.Println("Hello, World!")
}
```
#### `WithXxx()` Methods
> Each method, which starts with `With` can be tested by checking if it actually creates a new printer and sets the value.
Example from `SectionPrinter`:
```go
func TestSectionPrinter_WithStyle(t *testing.T) {
p := SectionPrinter{}
s := NewStyle(FgRed, BgRed, Bold)
p2 := p.WithStyle(s)
assert.Equal(t, s, p2.Style)
assert.Empty(t, p.Style)
}
func TestSectionPrinter_WithTopPadding(t *testing.T) {
p := SectionPrinter{}
p2 := p.WithTopPadding(1337)
assert.Equal(t, 1337, p2.TopPadding)
assert.Empty(t, p.TopPadding)
}
```
### `TextPrinter` Tests Template
```go
func TestTemplatePrinterPrintMethods(t *testing.T) { // TODO: Replace "Template" with actual printer name.
p := DefaultTemplate // TODO: Replace "Template" with actual printer name.
t.Run("Print", func(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
p.Print(a)
})
})
t.Run("Printf", func(t *testing.T) {
testPrintfContains(t, func(w io.Writer, format string, a interface{}) {
p.Printf(format, a)
})
})
t.Run("Println", func(t *testing.T) {
testPrintlnContains(t, func(w io.Writer, a interface{}) {
p.Println(a)
})
})
t.Run("Sprint", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint(a)
})
})
t.Run("Sprintf", func(t *testing.T) {
testSprintfContains(t, func(format string, a interface{}) string {
return p.Sprintf(format, a)
})
})
t.Run("Sprintln", func(t *testing.T) {
testSprintlnContains(t, func(a interface{}) string {
return p.Sprintln(a)
})
})
}
```
golang-github-pterm-pterm-0.12.79/LICENSE 0000664 0000000 0000000 00000002046 14650106263 0017705 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2020 pterm
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
golang-github-pterm-pterm-0.12.79/README.md 0000664 0000000 0000000 00000321214 14650106263 0020160 0 ustar 00root root 0000000 0000000
---
## 📦 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 😉
```sh
go get github.com/pterm/pterm
```
## ⭐ Main Features
| Feature | Description |
|------------------|-----------------------------------------------------|
| 🪀 Easy to use | PTerm emphasizes ease of use, with [examples](#-examples) and consistent component design. |
| 🤹♀️ Cross-Platform | PTerm works on various OS and terminals, including `Windows CMD`, `macOS iTerm2`, and in CI systems like `GitHub Actions`. |
| 🧪 Well tested | A high test coverage and `28774` automated tests ensure PTerm's reliability. |
| ✨ Consistent Colors | PTerm uses the [ANSI color scheme](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) for uniformity and supports `TrueColor` for advanced terminals. |
| 📚 Component system | PTerm's flexible `Printers` can be used individually or combined to generate beautiful console output. |
| 🛠 Configurable | PTerm is ready to use without configuration but allows easy customization for unique terminal output. |
| ✏ Documentation | Access comprehensive docs on [pkg.go.dev](https://pkg.go.dev/github.com/pterm/pterm#section-documentation) and view practical examples in the [examples section](#-examples). |
### Printers (Components)
### area/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print an informational message using PTerm's Info printer.
// This message will stay in place while the area updates.
pterm.Info.Println("The previous text will stay in place, while the area updates.")
// Print two new lines as spacer.
pterm.Print("\n\n")
// Start the Area printer from PTerm's DefaultArea, with the Center option.
// The Area printer allows us to update a specific area of the console output.
// The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 10 times to update the area with the current time.
for i := 0; i < 10; i++ {
// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
// The Srender() function is used to save the BigText as a string.
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
// Update the Area contents with the current time string.
area.Update(str)
// Sleep for a second before the next update.
time.Sleep(time.Second)
}
// Stop the Area printer after all updates are done.
area.Stop()
}
```
### area/center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area in the center of the terminal.
// The Start() function returns the created area and an error.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/default
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area and get a reference to it.
// The second return value is an error which is ignored here.
area, _ := pterm.DefaultArea.Start()
// Loop 5 times
for i := 0; i < 5; i++ {
// Update the content of the area dynamically.
// Here we're just displaying the current count.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
// This will clean up and free resources used by the area.
area.Stop()
}
```
### area/dynamic-chart
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen centered area.
// This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Ensure the area stops updating when we're done.
defer area.Stop()
// Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
// Create a new bar chart with dynamic bars.
// The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
// Render the bar chart to a string.
// This string will be used to update the area.
content, _ := barchart.Srender()
// Update the area with the new bar chart.
area.Update(content)
// Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
{Label: "A", Value: 10}, // A static bar.
{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
{Label: "C", Value: 30}, // Another static bar.
{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
```
### area/fullscreen
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen area. This will return an area instance and an error.
// The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
// Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/fullscreen-center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Initialize a new PTerm area with fullscreen and center options
// The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
// Update the content of the area with the current count
// The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second
time.Sleep(time.Second)
}
// Stop the area after all updates are done
// This will clear the area and return the terminal to its normal state
area.Stop()
}
```
### barchart/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the bars for the chart
bars := []pterm.Bar{
{Label: "Bar 1", Value: 5},
{Label: "Bar 2", Value: 3},
{Label: "Longer Label", Value: 7},
}
// Print an informational message
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
// Create a bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithBars(bars).Render()
// Create a horizontal bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
```
### barchart/custom-height
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of Bar structs. Each struct represents a bar in the chart.
// The Label field is the name of the bar and the Value field is the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create and render a bar chart with the defined bars and a height of 5.
// The WithBars method is used to set the bars of the chart.
// The WithHeight method is used to set the height of the chart.
// The Render method is used to display the chart in the terminal.
pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
```
### barchart/custom-width
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and has a width of 5
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
```
### barchart/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
// The `WithBars` method is used to set the bars of the chart.
// The `Render` method is used to display the chart.
pterm.DefaultBarChart.WithBars(bars).Render()
}
```
### barchart/horizontal
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is displayed horizontally
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
```
### barchart/horizontal-show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and displays the value of each bar
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
```
### barchart/mixed-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars for the chart.
// Each bar has a label and a value.
bars := []pterm.Bar{
{Label: "Bar 1", Value: 2},
{Label: "Bar 2", Value: -3},
{Label: "Bar 3", Value: -2},
{Label: "Bar 4", Value: 5},
{Label: "Longer Label", Value: 7},
}
// Print a section header.
// This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
// Create a bar chart with the defined bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
```
### barchart/negative-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars with negative values.
// Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
{Label: "Bar 1", Value: -5},
{Label: "Bar 2", Value: -3},
{Label: "Longer Label", Value: -7},
}
// Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
// Create a vertical bar chart with the defined bars.
// The WithShowValue() option is used to display the value of each bar in the chart.
// The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The WithHorizontal() option is used to orient the chart horizontally.
// The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
```
### barchart/show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of bars for the bar chart. Each bar is represented by a struct
// with a Label and a Value. The Label is a string that represents the name of the bar,
// and the Value is an integer that represents the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
// Chain the WithBars method to set the bars of the chart.
// Chain the WithShowValue method to display the value of each bar on the chart.
// Finally, call the Render method to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
```
### basictext/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// The DefaultBasicText is a basic text printer provided by PTerm.
// It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
// The DefaultBasicText can be used in any context that requires a TextPrinter.
// Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
// The DefaultBasicText is also useful for resolving progress bars and spinners.
}
```
### bigtext/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Create a large text with the LetterStyle from the standard theme.
// This is useful for creating title screens.
pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
// Create a large text with differently colored letters.
// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
// This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
).Render()
// Create a large text with a specific RGB color.
// This can be used when you need a specific color that is not available in the standard colors.
// Here, the color is gold (RGB: 255, 215, 0).
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
).Render()
}
```
### bigtext/colored
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Initialize a big text display with the letters "P" and "Term"
// "P" is displayed in cyan and "Term" is displayed in light magenta
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
Render() // Render the big text to the terminal
}
```
### bigtext/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define the text to be rendered
var text = "PTerm"
// Convert the text into a format suitable for PTerm
var letters = putils.LettersFromString(text)
// Render the text using PTerm's default big text style
pterm.DefaultBigText.WithLetters(letters).Render()
}
```
### box/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print an informational message.
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
// Create three panels with text, some of them with titles.
// The panels are created using the DefaultBox style.
panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
// Combine the panels into a layout using the DefaultPanel style.
// The layout is a 2D grid, with each row being an array of panels.
// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
{{Data: panel1}, {Data: panel2}},
{{Data: panel3}},
}).Srender()
// Print the panels layout inside a box with a title.
// The box is created using the DefaultBox style, with the title positioned at the bottom right.
pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
```
### box/custom-padding
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with custom padding options and print "Hello, World!" inside it.
pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
```
### box/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with PTerm and print a message in it.
// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
pterm.DefaultBox.Println("Hello, World!")
}
```
### box/title
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
// Define a title for the box
title := pterm.LightRed("I'm a box!")
// Create boxes with the title positioned differently and containing different content
box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
// Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
{{box7}},
}).Render()
}
```
### bulletlist/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a list of bullet list items with different levels.
bulletListItems := []pterm.BulletListItem{
{Level: 0, Text: "Level 0"}, // Level 0 item
{Level: 1, Text: "Level 1"}, // Level 1 item
{Level: 2, Text: "Level 2"}, // Level 2 item
}
// Use the default bullet list style to render the list items.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
// Define a string with different levels of indentation.
text := `0
1
2
3`
// Convert the indented string to a bullet list and render it.
putils.BulletListFromString(text, " ").Render()
}
```
### bulletlist/customized
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a list of bullet list items with different styles and levels.
bulletListItems := []pterm.BulletListItem{
{
Level: 0, // Level 0 (top level)
Text: "Blue", // Text to display
TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
},
{
Level: 1, // Level 1 (sub-item)
Text: "Green", // Text to display
TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
Bullet: "-", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
},
{
Level: 2, // Level 2 (sub-sub-item)
Text: "Cyan", // Text to display
TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
Bullet: ">", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
},
}
// Create a bullet list with the defined items and render it.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
```
### center/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print a block of text centered in the terminal
pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
// Generate BigLetters and store in 's'
s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
// Print the BigLetters 's' centered in the terminal
pterm.DefaultCenter.Println(s)
// Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
```
### coloring/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
}).Render() // Render the table.
pterm.Println()
// Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
// Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
// Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
```
### coloring/disable-output
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
// At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
// At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
// Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
```
### coloring/fade-colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
// Define the start and end points for the color gradient.
startColor := pterm.NewRGB(0, 255, 255) // Cyan
endColor := pterm.NewRGB(255, 0, 255) // Magenta
// Get the terminal height to determine the gradient range.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the range of the terminal height to create a color gradient.
for i := 0; i < terminalHeight-2; i++ {
// Calculate the fade factor for the current step in the gradient.
fadeFactor := float32(i) / float32(terminalHeight-2)
// Create a color that represents the current step in the gradient.
currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
// Print a string with the current color.
currentColor.Println("Hello, World!")
}
}
```
### coloring/fade-colors-rgb-style
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors
white := pterm.NewRGB(255, 255, 255)
grey := pterm.NewRGB(128, 128, 128)
black := pterm.NewRGB(0, 0, 0)
red := pterm.NewRGB(255, 0, 0)
purple := pterm.NewRGB(255, 0, 255)
green := pterm.NewRGB(0, 255, 0)
// Define strings to be printed
str1 := "RGB colors only work in Terminals which support TrueColor."
str2 := "The background and foreground colors can be customized individually."
str3 := "Styles can also be applied. For example: Bold or Italic."
// Print first string with color fading from white to purple
printFadedString(str1, white, purple, grey, black)
// Print second string with color fading from purple to red
printFadedString(str2, black, purple, red, red)
// Print third string with color fading from white to green and style changes
printStyledString(str3, white, green, red, black)
}
// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
boldStr := strings.Split("Bold", "")
italicStr := strings.Split("Italic", "")
bold, italic := 0, 0
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Check if the next letters are "Bold" or "Italic" and add the corresponding style
if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
style = style.AddOptions(pterm.Bold)
bold++
} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
style = style.AddOptions(pterm.Italic)
italic++
}
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
```
### coloring/fade-multiple-colors
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB values for gradient points.
startColor := pterm.NewRGB(0, 255, 255)
firstPoint := pterm.NewRGB(255, 0, 255)
secondPoint := pterm.NewRGB(255, 0, 0)
thirdPoint := pterm.NewRGB(0, 255, 0)
endColor := pterm.NewRGB(255, 255, 255)
// Define the string to be printed.
str := "RGB colors only work in Terminals which support TrueColor."
strs := strings.Split(str, "")
// Initialize an empty string for the faded info.
var fadeInfo string
// Loop over the string length to create a gradient effect.
for i := 0; i < len(str); i++ {
// Append each character of the string with a faded color to the info string.
fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
// Print the info string with gradient effect.
pterm.Info.Println(fadeInfo)
// Get the terminal height.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the terminal height to print "Hello, World!" with a gradient effect.
for i := 0; i < terminalHeight-2; i++ {
// Print the string with a color that fades from startColor to endColor.
startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
}
}
```
### coloring/override-default-printers
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default error message with PTerm's built-in Error style.
pterm.Error.Println("This is the default Error")
// Override the default error prefix with a new text and style.
pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
// Print the error message again, this time with the overridden prefix.
pterm.Error.Println("This is the default Error after the prefix was overridden")
}
```
### coloring/print-color-rgb
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a new RGB color with values 178, 44, 199.
// This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 15, 199, 209.
// This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 201, 144, 30.
// This color will be used for the background.
// The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
```
### coloring/print-color-rgb-style
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors for foreground and background.
foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
// Create a new RGB style with the defined foreground and background colors.
rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
// Print a string with the custom RGB style.
rgbStyle.Println("This text is not styled.")
// Add the 'Bold' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
// Add the 'Italic' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}
```
### demo/demo
SHOW SOURCE
```go
package main
import (
"flag"
"math/rand"
"reflect"
"strconv"
"strings"
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
// go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second
var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
setup() // Setup the demo (flags etc.)
// Show intro
if !*skipIntro {
introScreen()
clear()
}
showcase("Structured Logging", 5, func() {
logger := pterm.DefaultLogger.
WithLevel(pterm.LogLevelTrace)
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
time.Sleep(time.Second * 3)
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
time.Sleep(time.Second * 3)
logger.Info("That was actually interesting", logger.Args("such", "wow"))
time.Sleep(time.Second * 3)
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
time.Sleep(time.Second * 3)
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
time.Sleep(time.Second * 3)
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
})
showcase("Progress bar", 2, func() {
pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
for i := 0; i < pb.Total; i++ {
pb.UpdateTitle("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])
}
pb.Increment()
time.Sleep(second / 2)
}
pb.Stop()
})
showcase("Spinner", 2, func() {
list := pseudoProgramList[7:]
spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
for i := 0; i < len(list); i++ {
spinner.UpdateText("Installing " + list[i])
if list[i] == "pseudo-minecraft" {
pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
} else {
pterm.Success.Println("Installing " + list[i])
}
time.Sleep(second)
}
spinner.Success()
})
showcase("Live Output", 2, func() {
pterm.Info.Println("You can use an Area to display changing output:")
pterm.Println()
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
})
showcase("Tables", 4, func() {
for i := 0; i < 3; i++ {
pterm.Println()
}
td := [][]string{
{"Library", "Description"},
{"PTerm", "Make beautiful CLIs"},
{"Testza", "Programmer friendly test framework"},
{"Cursor", "Move the cursor around the terminal"},
}
table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
pterm.DefaultCenter.Println(table)
pterm.DefaultCenter.Println(boxedTable)
})
showcase("TrueColor Support", 7, func() {
from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
strs := strings.Split(str, "")
var fadeInfo string // String which will be used to print info.
// For loop over the range of the string length.
for i := 0; i < len(str); i++ {
// Append faded letter to info string.
fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
}
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
text := "All printers are fully customizable!"
area := pterm.DefaultArea.WithCenter()
area.Update(pterm.DefaultBox.Sprintln(text))
time.Sleep(second)
area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).
WithBottomPadding(1).
WithLeftPadding(1).
WithRightPadding(1).
WithHorizontalString("═").
WithVerticalString("║").
WithBottomLeftCornerString("╗").
WithBottomRightCornerString("╔").
WithTopLeftCornerString("╝").
WithTopRightCornerString("╚").
Sprintln(text))
area.Stop()
})
showcase("Themes", 2, func() {
pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
time.Sleep(second / 2)
// Print every value of the default theme with its own style.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
for i := 0; i < v.NumField(); i++ {
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
field.Println(typeOfS.Field(i).Name)
}
time.Sleep(time.Millisecond * 250)
}
}
})
showcase("And much more!", 3, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
box := pterm.DefaultBox.
WithBottomPadding(1).
WithTopPadding(1).
WithLeftPadding(3).
WithRightPadding(3).
Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
pterm.DefaultCenter.Println(box)
})
}
func setup() {
flag.Parse()
if *speedup {
second = time.Millisecond * 200
}
}
func introScreen() {
ptermLogo, _ := pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
Srender()
pterm.DefaultCenter.Print(ptermLogo)
pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("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.WithShowTimer(false).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()
}
func clear() {
print("\033[H\033[2J")
}
func showcase(title string, seconds int, content func()) {
pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
pterm.Println()
time.Sleep(second / 2)
content()
time.Sleep(second * time.Duration(seconds))
print("\033[H\033[2J")
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(max-min+1) + min
}
```
### header/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
// This uses the default settings of PTerm to print a header.
pterm.DefaultHeader.Println("This is the default header!")
// Print a spacer line for better readability.
pterm.Println()
// Print a full-width header.
// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
```
### header/custom
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
newHeader := pterm.HeaderPrinter{
TextStyle: pterm.NewStyle(pterm.FgBlack),
BackgroundStyle: pterm.NewStyle(pterm.BgRed),
Margin: 20,
}
// Print the custom header using the new HeaderPrinter.
newHeader.Println("This is a custom header!")
}
```
### heatmap/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the labels for the X and Y axes of the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Create a heatmap with the defined data and axis labels, and enable RGB colors.
// Then render the heatmap.
pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
```
### heatmap/custom_colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, and render it
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithLegend(false).
WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
WithLegend().
Render()
}
```
### heatmap/custom_legend
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the header data for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
pterm.Println()
// Create the heatmap with the defined data and options
// Options are chained in a single line for simplicity
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithEnableRGB().
WithLegendLabel("custom").
WithLegendOnlyColoredCells().
Render() // Render the heatmap
}
```
### heatmap/custom_rgb
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
axisLabels := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Define the color range for the heatmap.
rgbRange := []pterm.RGB{
pterm.NewRGB(0, 0, 255),
pterm.NewRGB(255, 0, 0),
pterm.NewRGB(0, 255, 0),
pterm.NewRGB(255, 255, 0),
}
// Create and render the heatmap.
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(axisLabels).
WithEnableRGB().
WithRGBRange(rgbRange...).
Render()
}
```
### heatmap/no_grid
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis data for the heatmap.
axisData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, then render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
```
### heatmap/separated
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
pterm.Println()
// Create the heatmap with the specified data and options, and render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
```
### interactive_confirm/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Show an interactive confirmation dialog and get the result.
result, _ := pterm.DefaultInteractiveConfirm.Show()
// Print a blank line for better readability.
pterm.Println()
// Print the user's answer in a formatted way.
pterm.Info.Printfln("You answered: %s", boolToText(result))
}
// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
if b {
return pterm.Green("Yes")
}
return pterm.Red("No")
}
```
### interactive_continue/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive continue prompt with default settings
// This will pause the program execution until the user presses enter
// The message displayed is "Press 'Enter' to continue..."
prompt := pterm.DefaultInteractiveContinue
// Show the prompt and wait for user input
// The returned result is the user's input (should be empty as it's a continue prompt)
// The second return value is an error which is ignored here
result, _ := prompt.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's input with an info prefix
// As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_multiselect/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options.
var options []string
// Populate the options slice with 100 options.
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Add 5 more options to the slice, indicating the availability of fuzzy searching.
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
// The Show() method displays the options and waits for user input.
selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
// Print the selected options, highlighted in green.
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-checkmarks
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and define the checkmark symbols
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-keys
SHOW SOURCE
```go
package main
import (
"atomicgo.dev/keyboard/keys"
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and set the keys for confirming and selecting options
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithKeyConfirm(keys.Enter).
WithKeySelect(keys.Space)
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_select/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Generate 100 options and add them to the options slice
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Generate 5 additional options with a specific message and add them to the options slice
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive select feature to present the options to the user and capture their selection
// The Show() method displays the options and waits for the user's input
selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
// Display the selected option to the user with a green color for emphasis
pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}
```
### interactive_textinput/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/default-value
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/multi-line
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create a default interactive text input with multi-line enabled.
// This allows the user to input multiple lines of text.
textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
// Show the text input to the user and store the result.
// The second return value (an error) is ignored with '_'.
result, _ := textInput.Show()
// Print a blank line for better readability in the output.
pterm.Println()
// Print the user's input prefixed with an informational message.
// The '%s' placeholder is replaced with the user's input.
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/password
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create an interactive text input with a mask for password input
passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
// Show the password input prompt and store the result
result, _ := passwordInput.Show("Enter your password")
// Get the default logger from PTerm
logger := pterm.DefaultLogger
// Log the received password (masked)
// Note: In a real-world application, you should never log passwords
logger.Info("Password received", logger.Args("password", result))
}
```
### logger/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with trace level
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace level message
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Pause for 3 seconds
sleep()
// Define a map with interesting stuff
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Pause for 3 seconds
sleep()
// Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Pause for 3 seconds
sleep()
// Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Pause for 3 seconds
sleep()
// Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Pause for 3 seconds
sleep()
// Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 3 seconds
sleep()
// Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
```
### logger/custom-key-styles
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Define a new style for the "priority" key.
priorityStyle := map[string]pterm.Style{
"priority": *pterm.NewStyle(pterm.FgRed),
}
// Overwrite all key styles with the new map.
logger = logger.WithKeyStyles(priorityStyle)
// Log an info message. The "priority" key will be displayed in red.
logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
// Define a new style for the "foo" key.
fooStyle := *pterm.NewStyle(pterm.FgBlue)
// Append the new style to the existing ones.
logger.AppendKeyStyle("foo", fooStyle)
// Log another info message. The "foo" key will be displayed in blue.
logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}
```
### logger/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Log an info message with additional arguments.
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments.
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments.
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 2 seconds.
time.Sleep(time.Second * 2)
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/json
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and JSON formatter
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
// Log a Trace level message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a Debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/with-caller
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and caller information
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
// Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### multiple-live-printers/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer for managing multiple printers
multi := pterm.DefaultMultiPrinter
// Create two spinners with their own writers
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create five progress bars with their own writers and a total of 100
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Increment progress bars and spinners based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment progress bar 1 every iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 to progress bar 2 every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment progress bar 3 every 5th iteration
}
if i%10 == 0 {
pb4.Increment() // Increment progress bar 4 every 10th iteration
}
if i%3 == 0 {
pb5.Increment() // Increment progress bar 5 every 3rd iteration
}
if i%50 == 0 {
spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
}
if i%60 == 0 {
spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
}
time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
}
// Stop the multi printer
multi.Stop()
}
```
### panel/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define panels in a 2D grid system
panels := pterm.Panels{
{
{Data: "This is the first panel"},
{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
{Data: "This\npanel\ncontains\nmultiple\nlines"},
},
{
{Data: pterm.Red("This is another\npanel line")},
{Data: "This is the second panel\nwith a new line"},
},
}
// Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
```
### paragraph/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Using the default paragraph printer to print a long text.
// The text is split at the spaces, which is useful for continuous text of all kinds.
// The line width can be manually adjusted if needed.
pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
// Printing a line space for separation.
pterm.Println()
// Printing a long text without using the paragraph printer.
// The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
```
### paragraph/customized
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a long text to be printed as a paragraph.
longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text as a paragraph with a custom maximal width of 60 characters.
pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
// Print a line space to separate the paragraph from the following text.
pterm.Println()
// Define another long text to be printed without a paragraph printer.
longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text without using a paragraph printer.
pterm.Println(longTextWithoutParagraph)
}
```
### prefix/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Enable debug messages in PTerm.
pterm.EnableDebugMessages()
// Print a debug message with PTerm.
pterm.Debug.Println("Hello, World!")
// Print an informational message with PTerm.
pterm.Info.Println("Hello, World!")
// Print a success message with PTerm.
pterm.Success.Println("Hello, World!")
// Print a warning message with PTerm.
pterm.Warning.Println("Hello, World!")
// Print an error message with PTerm. This will also display the filename and line number in the terminal.
pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
// Print an informational message with PTerm, with line number.
// This demonstrates that other PrefixPrinters can also display line numbers.
pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
// Temporarily set Fatal to false, so that the CI won't crash.
// This will print a fatal message with PTerm, but won't terminate the program.
pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
```
### progressbar/demo
SHOW SOURCE
```go
package main
import (
"strings"
"time"
"github.com/pterm/pterm"
)
// Slice of strings representing names of pseudo applications to be downloaded.
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", " ")
func main() {
// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
// Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
// Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
// Simulate a slow download for the 7th item.
if i == 6 {
time.Sleep(time.Second * 3)
}
// Update the title of the progressbar with the current item being downloaded.
p.UpdateTitle("Downloading " + fakeInstallList[i])
// Print a success message for the current download. This will be printed above the progressbar.
pterm.Success.Println("Downloading " + fakeInstallList[i])
// Increment the progressbar by one to indicate progress.
p.Increment()
// Pause for 350 milliseconds to simulate the time taken for each download.
time.Sleep(time.Millisecond * 350)
}
}
```
### progressbar/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer instance from the default one
multi := pterm.DefaultMultiPrinter
// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Loop to increment progress bars based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment the first progress bar at each iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment the third progress bar at every fifth iteration
}
if i%10 == 0 {
pb4.Increment() // Increment the fourth progress bar at every tenth iteration
}
if i%3 == 0 {
pb5.Increment() // Increment the fifth progress bar at every third iteration
}
time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
// Stop the multi printer
multi.Stop()
}
```
### section/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
// Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
// Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
// Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
```
### slog/demo
SHOW SOURCE
```go
package main
import (
"log/slog"
"github.com/pterm/pterm"
)
func main() {
// Create a new slog handler with the default PTerm logger
handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
// Create a new slog logger with the handler
logger := slog.New(handler)
// Log a debug message (won't show by default)
logger.Debug("This is a debug message that won't show")
// Change the log level to debug to enable debug messages
pterm.DefaultLogger.Level = pterm.LogLevelDebug
// Log a debug message (will show because debug level is enabled)
logger.Debug("This is a debug message", "changedLevel", true)
// Log an info message
logger.Info("This is an info message")
// Log a warning message
logger.Warn("This is a warning message")
// Log an error message
logger.Error("This is an error message")
}
```
### spinner/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create and start a fork of the default spinner.
spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerInfo.Info() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerSuccess.Success() // Resolve spinner with success message.
// Create and start a fork of the default spinner.
spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerWarning.Warning() // Resolve spinner with warning message.
// Create and start a fork of the default spinner.
spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerFail.Fail() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
// Replace the InfoPrinter with a custom "NOCHG" one
spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
MessageStyle: &pterm.Style{pterm.FgLightBlue},
Prefix: pterm.Prefix{
Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
Text: " NOCHG ",
},
}
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerNochange.Info("No change were required") // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
```
### spinner/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer. This allows multiple spinners to print simultaneously.
multi := pterm.DefaultMultiPrinter
// Create and start spinner 1 with a new writer from the multi printer.
// The spinner will display the message "Spinner 1".
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
// Create and start spinner 2 with a new writer from the multi printer.
// The spinner will display the message "Spinner 2".
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create and start spinner 3 with a new writer from the multi printer.
// The spinner will display the message "Spinner 3".
spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
// Start the multi printer. This will start printing all the spinners.
multi.Start()
// Wait for 1 second.
time.Sleep(time.Millisecond * 1000)
// Stop spinner 1 with a success message.
spinner1.Success("Spinner 1 is done!")
// Wait for 750 milliseconds.
time.Sleep(time.Millisecond * 750)
// Stop spinner 2 with a failure message.
spinner2.Fail("Spinner 2 failed!")
// Wait for 500 milliseconds.
time.Sleep(time.Millisecond * 500)
// Stop spinner 3 with a warning message.
spinner3.Warning("Spinner 3 has a warning!")
// Stop the multi printer. This will stop printing all the spinners.
multi.Stop()
}
```
### style/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
// Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
// Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
// Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
```
### table/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the first table
tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
pterm.Println() // Blank line
// Define the data for the second table
tableData2 := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create another table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
```
### table/boxed
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header of the table.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and is boxed.
// Finally, render the table to print it.
pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
```
### table/multiple-lines
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create and render the table.
// The options are chained in a single line for simplicity.
// The table has a header, a row separator, and a header row separator.
pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
```
### table/right-alignment
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and the text in the cells is right-aligned.
// The Render() method is used to print the table to the console.
pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
```
### theme/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"reflect"
"time"
)
func main() {
// Print an informational message about the default theme styles.
pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
// Print a blank line for better readability.
pterm.Println()
// Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
// Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
// Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
// Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
// Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
// Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
}
```
### tree/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
// The top node of the tree
Text: "Top node",
// The children of the top node
Children: []pterm.TreeNode{{
// A child node
Text: "Child node",
// The children of the child node
Children: []pterm.TreeNode{
// Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
},
}},
}
// Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
```
### tree/from-leveled-list
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
{Level: 0, Text: "C:"},
{Level: 1, Text: "Users"},
{Level: 1, Text: "Windows"},
{Level: 1, Text: "Programs"},
{Level: 1, Text: "Programs(x86)"},
{Level: 1, Text: "dev"},
{Level: 0, Text: "D:"},
{Level: 0, Text: "E:"},
{Level: 1, Text: "Movies"},
{Level: 1, Text: "Music"},
{Level: 2, Text: "LinkinPark"},
{Level: 1, Text: "Games"},
{Level: 2, Text: "Shooter"},
{Level: 3, Text: "CallOfDuty"},
{Level: 3, Text: "CS:GO"},
{Level: 3, Text: "Battlefield"},
{Level: 4, Text: "Battlefield 1"},
{Level: 4, Text: "Battlefield 2"},
{Level: 0, Text: "F:"},
{Level: 1, Text: "dev"},
{Level: 2, Text: "dops"},
{Level: 2, Text: "PTerm"},
}
// Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
root.Text = "Computer" // Set the root node text.
// Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
```
---
> GitHub [@pterm](https://github.com/pterm) ·
> Author [@MarvinJWendt](https://github.com/MarvinJWendt)
> | [PTerm.sh](https://pterm.sh)
golang-github-pterm-pterm-0.12.79/SECURITY.md 0000664 0000000 0000000 00000002720 14650106263 0020470 0 ustar 00root root 0000000 0000000 # PTerm Security Policy
This security policy applies to the PTerm GitHub repository and outlines the process for reporting security issues and handling security incidents. The primary goal of this policy is to ensure the safety and integrity of the PTerm codebase and to minimize the impact of security incidents on our users.
## 1. Overview
PTerm is a command-line interface (CLI) tool library, and we believe the security risks associated with it are minimal. However, we recognize that vulnerabilities can still arise, and we are committed to addressing them promptly and transparently.
## 2. Reporting Security Issues
If you discover a security issue in PTerm, please follow these steps:
Open a new issue in the PTerm GitHub repository, describing the security problem in detail.
## 3. Vulnerable Dependencies
If a dependency of PTerm is found to be vulnerable or infected and requires immediate updates, please follow these steps:
1. Open a new issue in the PTerm GitHub repository, describing the vulnerable dependency and the need for an update.
2. *Optional: Contact @MarvinJWendt directly via Twitter or Discord to alert them to the issue.*
## 4. Incident Response
Upon receiving a security report, the PTerm team will:
1. Acknowledge receipt of the report and review the issue.
2. Investigate the issue and determine the severity and impact.
3. Develop and implement a fix or mitigation plan, as necessary.
4. Update the PTerm repository and notify users, if applicable.
golang-github-pterm-pterm-0.12.79/_examples/ 0000775 0000000 0000000 00000000000 14650106263 0020653 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/README.md 0000664 0000000 0000000 00000301735 14650106263 0022143 0 ustar 00root root 0000000 0000000 # PTerm Examples
> This directory contains examples of using the PTerm library.
### area/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print an informational message using PTerm's Info printer.
// This message will stay in place while the area updates.
pterm.Info.Println("The previous text will stay in place, while the area updates.")
// Print two new lines as spacer.
pterm.Print("\n\n")
// Start the Area printer from PTerm's DefaultArea, with the Center option.
// The Area printer allows us to update a specific area of the console output.
// The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 10 times to update the area with the current time.
for i := 0; i < 10; i++ {
// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
// The Srender() function is used to save the BigText as a string.
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
// Update the Area contents with the current time string.
area.Update(str)
// Sleep for a second before the next update.
time.Sleep(time.Second)
}
// Stop the Area printer after all updates are done.
area.Stop()
}
```
### area/center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area in the center of the terminal.
// The Start() function returns the created area and an error.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/default
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area and get a reference to it.
// The second return value is an error which is ignored here.
area, _ := pterm.DefaultArea.Start()
// Loop 5 times
for i := 0; i < 5; i++ {
// Update the content of the area dynamically.
// Here we're just displaying the current count.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
// This will clean up and free resources used by the area.
area.Stop()
}
```
### area/dynamic-chart
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen centered area.
// This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Ensure the area stops updating when we're done.
defer area.Stop()
// Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
// Create a new bar chart with dynamic bars.
// The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
// Render the bar chart to a string.
// This string will be used to update the area.
content, _ := barchart.Srender()
// Update the area with the new bar chart.
area.Update(content)
// Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
{Label: "A", Value: 10}, // A static bar.
{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
{Label: "C", Value: 30}, // Another static bar.
{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
```
### area/fullscreen
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen area. This will return an area instance and an error.
// The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
// Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/fullscreen-center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Initialize a new PTerm area with fullscreen and center options
// The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
// Update the content of the area with the current count
// The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second
time.Sleep(time.Second)
}
// Stop the area after all updates are done
// This will clear the area and return the terminal to its normal state
area.Stop()
}
```
### barchart/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the bars for the chart
bars := []pterm.Bar{
{Label: "Bar 1", Value: 5},
{Label: "Bar 2", Value: 3},
{Label: "Longer Label", Value: 7},
}
// Print an informational message
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
// Create a bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithBars(bars).Render()
// Create a horizontal bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
```
### barchart/custom-height
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of Bar structs. Each struct represents a bar in the chart.
// The Label field is the name of the bar and the Value field is the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create and render a bar chart with the defined bars and a height of 5.
// The WithBars method is used to set the bars of the chart.
// The WithHeight method is used to set the height of the chart.
// The Render method is used to display the chart in the terminal.
pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
```
### barchart/custom-width
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and has a width of 5
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
```
### barchart/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
// The `WithBars` method is used to set the bars of the chart.
// The `Render` method is used to display the chart.
pterm.DefaultBarChart.WithBars(bars).Render()
}
```
### barchart/horizontal
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is displayed horizontally
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
```
### barchart/horizontal-show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and displays the value of each bar
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
```
### barchart/mixed-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars for the chart.
// Each bar has a label and a value.
bars := []pterm.Bar{
{Label: "Bar 1", Value: 2},
{Label: "Bar 2", Value: -3},
{Label: "Bar 3", Value: -2},
{Label: "Bar 4", Value: 5},
{Label: "Longer Label", Value: 7},
}
// Print a section header.
// This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
// Create a bar chart with the defined bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
```
### barchart/negative-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars with negative values.
// Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
{Label: "Bar 1", Value: -5},
{Label: "Bar 2", Value: -3},
{Label: "Longer Label", Value: -7},
}
// Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
// Create a vertical bar chart with the defined bars.
// The WithShowValue() option is used to display the value of each bar in the chart.
// The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The WithHorizontal() option is used to orient the chart horizontally.
// The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
```
### barchart/show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of bars for the bar chart. Each bar is represented by a struct
// with a Label and a Value. The Label is a string that represents the name of the bar,
// and the Value is an integer that represents the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
// Chain the WithBars method to set the bars of the chart.
// Chain the WithShowValue method to display the value of each bar on the chart.
// Finally, call the Render method to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
```
### basictext/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// The DefaultBasicText is a basic text printer provided by PTerm.
// It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
// The DefaultBasicText can be used in any context that requires a TextPrinter.
// Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
// The DefaultBasicText is also useful for resolving progress bars and spinners.
}
```
### bigtext/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Create a large text with the LetterStyle from the standard theme.
// This is useful for creating title screens.
pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
// Create a large text with differently colored letters.
// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
// This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
).Render()
// Create a large text with a specific RGB color.
// This can be used when you need a specific color that is not available in the standard colors.
// Here, the color is gold (RGB: 255, 215, 0).
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
).Render()
}
```
### bigtext/colored
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Initialize a big text display with the letters "P" and "Term"
// "P" is displayed in cyan and "Term" is displayed in light magenta
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
Render() // Render the big text to the terminal
}
```
### bigtext/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define the text to be rendered
var text = "PTerm"
// Convert the text into a format suitable for PTerm
var letters = putils.LettersFromString(text)
// Render the text using PTerm's default big text style
pterm.DefaultBigText.WithLetters(letters).Render()
}
```
### box/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print an informational message.
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
// Create three panels with text, some of them with titles.
// The panels are created using the DefaultBox style.
panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
// Combine the panels into a layout using the DefaultPanel style.
// The layout is a 2D grid, with each row being an array of panels.
// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
{{Data: panel1}, {Data: panel2}},
{{Data: panel3}},
}).Srender()
// Print the panels layout inside a box with a title.
// The box is created using the DefaultBox style, with the title positioned at the bottom right.
pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
```
### box/custom-padding
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with custom padding options and print "Hello, World!" inside it.
pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
```
### box/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with PTerm and print a message in it.
// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
pterm.DefaultBox.Println("Hello, World!")
}
```
### box/title
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
// Define a title for the box
title := pterm.LightRed("I'm a box!")
// Create boxes with the title positioned differently and containing different content
box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
// Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
{{box7}},
}).Render()
}
```
### bulletlist/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a list of bullet list items with different levels.
bulletListItems := []pterm.BulletListItem{
{Level: 0, Text: "Level 0"}, // Level 0 item
{Level: 1, Text: "Level 1"}, // Level 1 item
{Level: 2, Text: "Level 2"}, // Level 2 item
}
// Use the default bullet list style to render the list items.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
// Define a string with different levels of indentation.
text := `0
1
2
3`
// Convert the indented string to a bullet list and render it.
putils.BulletListFromString(text, " ").Render()
}
```
### bulletlist/customized
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a list of bullet list items with different styles and levels.
bulletListItems := []pterm.BulletListItem{
{
Level: 0, // Level 0 (top level)
Text: "Blue", // Text to display
TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
},
{
Level: 1, // Level 1 (sub-item)
Text: "Green", // Text to display
TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
Bullet: "-", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
},
{
Level: 2, // Level 2 (sub-sub-item)
Text: "Cyan", // Text to display
TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
Bullet: ">", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
},
}
// Create a bullet list with the defined items and render it.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
```
### center/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print a block of text centered in the terminal
pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
// Generate BigLetters and store in 's'
s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
// Print the BigLetters 's' centered in the terminal
pterm.DefaultCenter.Println(s)
// Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
```
### coloring/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
}).Render() // Render the table.
pterm.Println()
// Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
// Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
// Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
```
### coloring/disable-output
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
// At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
// At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
// Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
```
### coloring/fade-colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
// Define the start and end points for the color gradient.
startColor := pterm.NewRGB(0, 255, 255) // Cyan
endColor := pterm.NewRGB(255, 0, 255) // Magenta
// Get the terminal height to determine the gradient range.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the range of the terminal height to create a color gradient.
for i := 0; i < terminalHeight-2; i++ {
// Calculate the fade factor for the current step in the gradient.
fadeFactor := float32(i) / float32(terminalHeight-2)
// Create a color that represents the current step in the gradient.
currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
// Print a string with the current color.
currentColor.Println("Hello, World!")
}
}
```
### coloring/fade-colors-rgb-style
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors
white := pterm.NewRGB(255, 255, 255)
grey := pterm.NewRGB(128, 128, 128)
black := pterm.NewRGB(0, 0, 0)
red := pterm.NewRGB(255, 0, 0)
purple := pterm.NewRGB(255, 0, 255)
green := pterm.NewRGB(0, 255, 0)
// Define strings to be printed
str1 := "RGB colors only work in Terminals which support TrueColor."
str2 := "The background and foreground colors can be customized individually."
str3 := "Styles can also be applied. For example: Bold or Italic."
// Print first string with color fading from white to purple
printFadedString(str1, white, purple, grey, black)
// Print second string with color fading from purple to red
printFadedString(str2, black, purple, red, red)
// Print third string with color fading from white to green and style changes
printStyledString(str3, white, green, red, black)
}
// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
boldStr := strings.Split("Bold", "")
italicStr := strings.Split("Italic", "")
bold, italic := 0, 0
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Check if the next letters are "Bold" or "Italic" and add the corresponding style
if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
style = style.AddOptions(pterm.Bold)
bold++
} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
style = style.AddOptions(pterm.Italic)
italic++
}
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
```
### coloring/fade-multiple-colors
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB values for gradient points.
startColor := pterm.NewRGB(0, 255, 255)
firstPoint := pterm.NewRGB(255, 0, 255)
secondPoint := pterm.NewRGB(255, 0, 0)
thirdPoint := pterm.NewRGB(0, 255, 0)
endColor := pterm.NewRGB(255, 255, 255)
// Define the string to be printed.
str := "RGB colors only work in Terminals which support TrueColor."
strs := strings.Split(str, "")
// Initialize an empty string for the faded info.
var fadeInfo string
// Loop over the string length to create a gradient effect.
for i := 0; i < len(str); i++ {
// Append each character of the string with a faded color to the info string.
fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
// Print the info string with gradient effect.
pterm.Info.Println(fadeInfo)
// Get the terminal height.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the terminal height to print "Hello, World!" with a gradient effect.
for i := 0; i < terminalHeight-2; i++ {
// Print the string with a color that fades from startColor to endColor.
startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
}
}
```
### coloring/override-default-printers
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default error message with PTerm's built-in Error style.
pterm.Error.Println("This is the default Error")
// Override the default error prefix with a new text and style.
pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
// Print the error message again, this time with the overridden prefix.
pterm.Error.Println("This is the default Error after the prefix was overridden")
}
```
### coloring/print-color-rgb
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a new RGB color with values 178, 44, 199.
// This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 15, 199, 209.
// This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 201, 144, 30.
// This color will be used for the background.
// The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
```
### coloring/print-color-rgb-style
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors for foreground and background.
foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
// Create a new RGB style with the defined foreground and background colors.
rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
// Print a string with the custom RGB style.
rgbStyle.Println("This text is not styled.")
// Add the 'Bold' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
// Add the 'Italic' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}
```
### demo/demo
SHOW SOURCE
```go
package main
import (
"flag"
"math/rand"
"reflect"
"strconv"
"strings"
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
// go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second
var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
setup() // Setup the demo (flags etc.)
// Show intro
if !*skipIntro {
introScreen()
clear()
}
showcase("Structured Logging", 5, func() {
logger := pterm.DefaultLogger.
WithLevel(pterm.LogLevelTrace)
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
time.Sleep(time.Second * 3)
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
time.Sleep(time.Second * 3)
logger.Info("That was actually interesting", logger.Args("such", "wow"))
time.Sleep(time.Second * 3)
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
time.Sleep(time.Second * 3)
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
time.Sleep(time.Second * 3)
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
})
showcase("Progress bar", 2, func() {
pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
for i := 0; i < pb.Total; i++ {
pb.UpdateTitle("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])
}
pb.Increment()
time.Sleep(second / 2)
}
pb.Stop()
})
showcase("Spinner", 2, func() {
list := pseudoProgramList[7:]
spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
for i := 0; i < len(list); i++ {
spinner.UpdateText("Installing " + list[i])
if list[i] == "pseudo-minecraft" {
pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
} else {
pterm.Success.Println("Installing " + list[i])
}
time.Sleep(second)
}
spinner.Success()
})
showcase("Live Output", 2, func() {
pterm.Info.Println("You can use an Area to display changing output:")
pterm.Println()
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
})
showcase("Tables", 4, func() {
for i := 0; i < 3; i++ {
pterm.Println()
}
td := [][]string{
{"Library", "Description"},
{"PTerm", "Make beautiful CLIs"},
{"Testza", "Programmer friendly test framework"},
{"Cursor", "Move the cursor around the terminal"},
}
table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
pterm.DefaultCenter.Println(table)
pterm.DefaultCenter.Println(boxedTable)
})
showcase("TrueColor Support", 7, func() {
from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
strs := strings.Split(str, "")
var fadeInfo string // String which will be used to print info.
// For loop over the range of the string length.
for i := 0; i < len(str); i++ {
// Append faded letter to info string.
fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
}
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
text := "All printers are fully customizable!"
area := pterm.DefaultArea.WithCenter()
area.Update(pterm.DefaultBox.Sprintln(text))
time.Sleep(second)
area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).
WithBottomPadding(1).
WithLeftPadding(1).
WithRightPadding(1).
WithHorizontalString("═").
WithVerticalString("║").
WithBottomLeftCornerString("╗").
WithBottomRightCornerString("╔").
WithTopLeftCornerString("╝").
WithTopRightCornerString("╚").
Sprintln(text))
area.Stop()
})
showcase("Themes", 2, func() {
pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
time.Sleep(second / 2)
// Print every value of the default theme with its own style.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
for i := 0; i < v.NumField(); i++ {
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
field.Println(typeOfS.Field(i).Name)
}
time.Sleep(time.Millisecond * 250)
}
}
})
showcase("And much more!", 3, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
box := pterm.DefaultBox.
WithBottomPadding(1).
WithTopPadding(1).
WithLeftPadding(3).
WithRightPadding(3).
Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
pterm.DefaultCenter.Println(box)
})
}
func setup() {
flag.Parse()
if *speedup {
second = time.Millisecond * 200
}
}
func introScreen() {
ptermLogo, _ := pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
Srender()
pterm.DefaultCenter.Print(ptermLogo)
pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("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.WithShowTimer(false).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()
}
func clear() {
print("\033[H\033[2J")
}
func showcase(title string, seconds int, content func()) {
pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
pterm.Println()
time.Sleep(second / 2)
content()
time.Sleep(second * time.Duration(seconds))
print("\033[H\033[2J")
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(max-min+1) + min
}
```
### header/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
// This uses the default settings of PTerm to print a header.
pterm.DefaultHeader.Println("This is the default header!")
// Print a spacer line for better readability.
pterm.Println()
// Print a full-width header.
// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
```
### header/custom
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
newHeader := pterm.HeaderPrinter{
TextStyle: pterm.NewStyle(pterm.FgBlack),
BackgroundStyle: pterm.NewStyle(pterm.BgRed),
Margin: 20,
}
// Print the custom header using the new HeaderPrinter.
newHeader.Println("This is a custom header!")
}
```
### heatmap/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the labels for the X and Y axes of the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Create a heatmap with the defined data and axis labels, and enable RGB colors.
// Then render the heatmap.
pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
```
### heatmap/custom_colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, and render it
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithLegend(false).
WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
WithLegend().
Render()
}
```
### heatmap/custom_legend
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the header data for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
pterm.Println()
// Create the heatmap with the defined data and options
// Options are chained in a single line for simplicity
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithEnableRGB().
WithLegendLabel("custom").
WithLegendOnlyColoredCells().
Render() // Render the heatmap
}
```
### heatmap/custom_rgb
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
axisLabels := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Define the color range for the heatmap.
rgbRange := []pterm.RGB{
pterm.NewRGB(0, 0, 255),
pterm.NewRGB(255, 0, 0),
pterm.NewRGB(0, 255, 0),
pterm.NewRGB(255, 255, 0),
}
// Create and render the heatmap.
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(axisLabels).
WithEnableRGB().
WithRGBRange(rgbRange...).
Render()
}
```
### heatmap/no_grid
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis data for the heatmap.
axisData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, then render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
```
### heatmap/separated
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
pterm.Println()
// Create the heatmap with the specified data and options, and render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
```
### interactive_confirm/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Show an interactive confirmation dialog and get the result.
result, _ := pterm.DefaultInteractiveConfirm.Show()
// Print a blank line for better readability.
pterm.Println()
// Print the user's answer in a formatted way.
pterm.Info.Printfln("You answered: %s", boolToText(result))
}
// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
if b {
return pterm.Green("Yes")
}
return pterm.Red("No")
}
```
### interactive_continue/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive continue prompt with default settings
// This will pause the program execution until the user presses enter
// The message displayed is "Press 'Enter' to continue..."
prompt := pterm.DefaultInteractiveContinue
// Show the prompt and wait for user input
// The returned result is the user's input (should be empty as it's a continue prompt)
// The second return value is an error which is ignored here
result, _ := prompt.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's input with an info prefix
// As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_multiselect/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options.
var options []string
// Populate the options slice with 100 options.
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Add 5 more options to the slice, indicating the availability of fuzzy searching.
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
// The Show() method displays the options and waits for user input.
selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
// Print the selected options, highlighted in green.
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-checkmarks
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and define the checkmark symbols
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-keys
SHOW SOURCE
```go
package main
import (
"atomicgo.dev/keyboard/keys"
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and set the keys for confirming and selecting options
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithKeyConfirm(keys.Enter).
WithKeySelect(keys.Space)
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_select/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Generate 100 options and add them to the options slice
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Generate 5 additional options with a specific message and add them to the options slice
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive select feature to present the options to the user and capture their selection
// The Show() method displays the options and waits for the user's input
selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
// Display the selected option to the user with a green color for emphasis
pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}
```
### interactive_textinput/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/default-value
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/multi-line
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create a default interactive text input with multi-line enabled.
// This allows the user to input multiple lines of text.
textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
// Show the text input to the user and store the result.
// The second return value (an error) is ignored with '_'.
result, _ := textInput.Show()
// Print a blank line for better readability in the output.
pterm.Println()
// Print the user's input prefixed with an informational message.
// The '%s' placeholder is replaced with the user's input.
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/password
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create an interactive text input with a mask for password input
passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
// Show the password input prompt and store the result
result, _ := passwordInput.Show("Enter your password")
// Get the default logger from PTerm
logger := pterm.DefaultLogger
// Log the received password (masked)
// Note: In a real-world application, you should never log passwords
logger.Info("Password received", logger.Args("password", result))
}
```
### logger/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with trace level
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace level message
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Pause for 3 seconds
sleep()
// Define a map with interesting stuff
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Pause for 3 seconds
sleep()
// Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Pause for 3 seconds
sleep()
// Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Pause for 3 seconds
sleep()
// Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Pause for 3 seconds
sleep()
// Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 3 seconds
sleep()
// Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
```
### logger/custom-key-styles
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Define a new style for the "priority" key.
priorityStyle := map[string]pterm.Style{
"priority": *pterm.NewStyle(pterm.FgRed),
}
// Overwrite all key styles with the new map.
logger = logger.WithKeyStyles(priorityStyle)
// Log an info message. The "priority" key will be displayed in red.
logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
// Define a new style for the "foo" key.
fooStyle := *pterm.NewStyle(pterm.FgBlue)
// Append the new style to the existing ones.
logger.AppendKeyStyle("foo", fooStyle)
// Log another info message. The "foo" key will be displayed in blue.
logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}
```
### logger/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Log an info message with additional arguments.
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments.
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments.
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 2 seconds.
time.Sleep(time.Second * 2)
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/json
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and JSON formatter
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
// Log a Trace level message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a Debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/with-caller
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and caller information
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
// Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### multiple-live-printers/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer for managing multiple printers
multi := pterm.DefaultMultiPrinter
// Create two spinners with their own writers
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create five progress bars with their own writers and a total of 100
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Increment progress bars and spinners based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment progress bar 1 every iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 to progress bar 2 every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment progress bar 3 every 5th iteration
}
if i%10 == 0 {
pb4.Increment() // Increment progress bar 4 every 10th iteration
}
if i%3 == 0 {
pb5.Increment() // Increment progress bar 5 every 3rd iteration
}
if i%50 == 0 {
spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
}
if i%60 == 0 {
spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
}
time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
}
// Stop the multi printer
multi.Stop()
}
```
### panel/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define panels in a 2D grid system
panels := pterm.Panels{
{
{Data: "This is the first panel"},
{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
{Data: "This\npanel\ncontains\nmultiple\nlines"},
},
{
{Data: pterm.Red("This is another\npanel line")},
{Data: "This is the second panel\nwith a new line"},
},
}
// Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
```
### paragraph/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Using the default paragraph printer to print a long text.
// The text is split at the spaces, which is useful for continuous text of all kinds.
// The line width can be manually adjusted if needed.
pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
// Printing a line space for separation.
pterm.Println()
// Printing a long text without using the paragraph printer.
// The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
```
### paragraph/customized
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a long text to be printed as a paragraph.
longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text as a paragraph with a custom maximal width of 60 characters.
pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
// Print a line space to separate the paragraph from the following text.
pterm.Println()
// Define another long text to be printed without a paragraph printer.
longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text without using a paragraph printer.
pterm.Println(longTextWithoutParagraph)
}
```
### prefix/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Enable debug messages in PTerm.
pterm.EnableDebugMessages()
// Print a debug message with PTerm.
pterm.Debug.Println("Hello, World!")
// Print an informational message with PTerm.
pterm.Info.Println("Hello, World!")
// Print a success message with PTerm.
pterm.Success.Println("Hello, World!")
// Print a warning message with PTerm.
pterm.Warning.Println("Hello, World!")
// Print an error message with PTerm. This will also display the filename and line number in the terminal.
pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
// Print an informational message with PTerm, with line number.
// This demonstrates that other PrefixPrinters can also display line numbers.
pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
// Temporarily set Fatal to false, so that the CI won't crash.
// This will print a fatal message with PTerm, but won't terminate the program.
pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
```
### progressbar/demo
SHOW SOURCE
```go
package main
import (
"strings"
"time"
"github.com/pterm/pterm"
)
// Slice of strings representing names of pseudo applications to be downloaded.
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", " ")
func main() {
// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
// Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
// Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
// Simulate a slow download for the 7th item.
if i == 6 {
time.Sleep(time.Second * 3)
}
// Update the title of the progressbar with the current item being downloaded.
p.UpdateTitle("Downloading " + fakeInstallList[i])
// Print a success message for the current download. This will be printed above the progressbar.
pterm.Success.Println("Downloading " + fakeInstallList[i])
// Increment the progressbar by one to indicate progress.
p.Increment()
// Pause for 350 milliseconds to simulate the time taken for each download.
time.Sleep(time.Millisecond * 350)
}
}
```
### progressbar/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer instance from the default one
multi := pterm.DefaultMultiPrinter
// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Loop to increment progress bars based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment the first progress bar at each iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment the third progress bar at every fifth iteration
}
if i%10 == 0 {
pb4.Increment() // Increment the fourth progress bar at every tenth iteration
}
if i%3 == 0 {
pb5.Increment() // Increment the fifth progress bar at every third iteration
}
time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
// Stop the multi printer
multi.Stop()
}
```
### section/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
// Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
// Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
// Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
```
### slog/demo
SHOW SOURCE
```go
package main
import (
"log/slog"
"github.com/pterm/pterm"
)
func main() {
// Create a new slog handler with the default PTerm logger
handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
// Create a new slog logger with the handler
logger := slog.New(handler)
// Log a debug message (won't show by default)
logger.Debug("This is a debug message that won't show")
// Change the log level to debug to enable debug messages
pterm.DefaultLogger.Level = pterm.LogLevelDebug
// Log a debug message (will show because debug level is enabled)
logger.Debug("This is a debug message", "changedLevel", true)
// Log an info message
logger.Info("This is an info message")
// Log a warning message
logger.Warn("This is a warning message")
// Log an error message
logger.Error("This is an error message")
}
```
### spinner/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create and start a fork of the default spinner.
spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerInfo.Info() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerSuccess.Success() // Resolve spinner with success message.
// Create and start a fork of the default spinner.
spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerWarning.Warning() // Resolve spinner with warning message.
// Create and start a fork of the default spinner.
spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerFail.Fail() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
// Replace the InfoPrinter with a custom "NOCHG" one
spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
MessageStyle: &pterm.Style{pterm.FgLightBlue},
Prefix: pterm.Prefix{
Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
Text: " NOCHG ",
},
}
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerNochange.Info("No change were required") // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
```
### spinner/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer. This allows multiple spinners to print simultaneously.
multi := pterm.DefaultMultiPrinter
// Create and start spinner 1 with a new writer from the multi printer.
// The spinner will display the message "Spinner 1".
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
// Create and start spinner 2 with a new writer from the multi printer.
// The spinner will display the message "Spinner 2".
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create and start spinner 3 with a new writer from the multi printer.
// The spinner will display the message "Spinner 3".
spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
// Start the multi printer. This will start printing all the spinners.
multi.Start()
// Wait for 1 second.
time.Sleep(time.Millisecond * 1000)
// Stop spinner 1 with a success message.
spinner1.Success("Spinner 1 is done!")
// Wait for 750 milliseconds.
time.Sleep(time.Millisecond * 750)
// Stop spinner 2 with a failure message.
spinner2.Fail("Spinner 2 failed!")
// Wait for 500 milliseconds.
time.Sleep(time.Millisecond * 500)
// Stop spinner 3 with a warning message.
spinner3.Warning("Spinner 3 has a warning!")
// Stop the multi printer. This will stop printing all the spinners.
multi.Stop()
}
```
### style/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
// Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
// Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
// Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
```
### table/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the first table
tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
pterm.Println() // Blank line
// Define the data for the second table
tableData2 := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create another table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
```
### table/boxed
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header of the table.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and is boxed.
// Finally, render the table to print it.
pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
```
### table/multiple-lines
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create and render the table.
// The options are chained in a single line for simplicity.
// The table has a header, a row separator, and a header row separator.
pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
```
### table/right-alignment
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and the text in the cells is right-aligned.
// The Render() method is used to print the table to the console.
pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
```
### theme/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"reflect"
"time"
)
func main() {
// Print an informational message about the default theme styles.
pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
// Print a blank line for better readability.
pterm.Println()
// Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
// Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
// Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
// Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
// Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
// Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
}
```
### tree/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
// The top node of the tree
Text: "Top node",
// The children of the top node
Children: []pterm.TreeNode{{
// A child node
Text: "Child node",
// The children of the child node
Children: []pterm.TreeNode{
// Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
},
}},
}
// Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
```
### tree/from-leveled-list
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
{Level: 0, Text: "C:"},
{Level: 1, Text: "Users"},
{Level: 1, Text: "Windows"},
{Level: 1, Text: "Programs"},
{Level: 1, Text: "Programs(x86)"},
{Level: 1, Text: "dev"},
{Level: 0, Text: "D:"},
{Level: 0, Text: "E:"},
{Level: 1, Text: "Movies"},
{Level: 1, Text: "Music"},
{Level: 2, Text: "LinkinPark"},
{Level: 1, Text: "Games"},
{Level: 2, Text: "Shooter"},
{Level: 3, Text: "CallOfDuty"},
{Level: 3, Text: "CS:GO"},
{Level: 3, Text: "Battlefield"},
{Level: 4, Text: "Battlefield 1"},
{Level: 4, Text: "Battlefield 2"},
{Level: 0, Text: "F:"},
{Level: 1, Text: "dev"},
{Level: 2, Text: "dops"},
{Level: 2, Text: "PTerm"},
}
// Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
root.Text = "Computer" // Set the root node text.
// Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/ 0000775 0000000 0000000 00000000000 14650106263 0021563 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/README.md 0000664 0000000 0000000 00000014744 14650106263 0023054 0 ustar 00root root 0000000 0000000 ### area/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print an informational message using PTerm's Info printer.
// This message will stay in place while the area updates.
pterm.Info.Println("The previous text will stay in place, while the area updates.")
// Print two new lines as spacer.
pterm.Print("\n\n")
// Start the Area printer from PTerm's DefaultArea, with the Center option.
// The Area printer allows us to update a specific area of the console output.
// The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 10 times to update the area with the current time.
for i := 0; i < 10; i++ {
// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
// The Srender() function is used to save the BigText as a string.
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
// Update the Area contents with the current time string.
area.Update(str)
// Sleep for a second before the next update.
time.Sleep(time.Second)
}
// Stop the Area printer after all updates are done.
area.Stop()
}
```
### area/center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area in the center of the terminal.
// The Start() function returns the created area and an error.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/default
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area and get a reference to it.
// The second return value is an error which is ignored here.
area, _ := pterm.DefaultArea.Start()
// Loop 5 times
for i := 0; i < 5; i++ {
// Update the content of the area dynamically.
// Here we're just displaying the current count.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
// This will clean up and free resources used by the area.
area.Stop()
}
```
### area/dynamic-chart
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen centered area.
// This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Ensure the area stops updating when we're done.
defer area.Stop()
// Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
// Create a new bar chart with dynamic bars.
// The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
// Render the bar chart to a string.
// This string will be used to update the area.
content, _ := barchart.Srender()
// Update the area with the new bar chart.
area.Update(content)
// Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
{Label: "A", Value: 10}, // A static bar.
{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
{Label: "C", Value: 30}, // Another static bar.
{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
```
### area/fullscreen
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen area. This will return an area instance and an error.
// The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
// Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
### area/fullscreen-center
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Initialize a new PTerm area with fullscreen and center options
// The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
// Update the content of the area with the current count
// The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second
time.Sleep(time.Second)
}
// Stop the area after all updates are done
// This will clear the area and return the terminal to its normal state
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/center/ 0000775 0000000 0000000 00000000000 14650106263 0023043 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/center/README.md 0000664 0000000 0000000 00000001350 14650106263 0024321 0 ustar 00root root 0000000 0000000 # area/center
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area in the center of the terminal.
// The Start() function returns the created area and an error.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/center/animation.svg 0000664 0000000 0000000 00000012652 14650106263 0025551 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/center/main.go 0000664 0000000 0000000 00000001261 14650106263 0024316 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area in the center of the terminal.
// The Start() function returns the created area and an error.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 5 times to simulate a dynamic update.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second to simulate a time-consuming task.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/area/default/ 0000775 0000000 0000000 00000000000 14650106263 0023207 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/default/README.md 0000664 0000000 0000000 00000001332 14650106263 0024465 0 ustar 00root root 0000000 0000000 # area/default
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area and get a reference to it.
// The second return value is an error which is ignored here.
area, _ := pterm.DefaultArea.Start()
// Loop 5 times
for i := 0; i < 5; i++ {
// Update the content of the area dynamically.
// Here we're just displaying the current count.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
// This will clean up and free resources used by the area.
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/default/animation.svg 0000664 0000000 0000000 00000010220 14650106263 0025702 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/default/main.go 0000664 0000000 0000000 00000001242 14650106263 0024461 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new default area and get a reference to it.
// The second return value is an error which is ignored here.
area, _ := pterm.DefaultArea.Start()
// Loop 5 times
for i := 0; i < 5; i++ {
// Update the content of the area dynamically.
// Here we're just displaying the current count.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
// This will clean up and free resources used by the area.
area.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/area/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022507 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/demo/README.md 0000664 0000000 0000000 00000002604 14650106263 0023770 0 ustar 00root root 0000000 0000000 # area/demo
```go
package main
import (
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print an informational message using PTerm's Info printer.
// This message will stay in place while the area updates.
pterm.Info.Println("The previous text will stay in place, while the area updates.")
// Print two new lines as spacer.
pterm.Print("\n\n")
// Start the Area printer from PTerm's DefaultArea, with the Center option.
// The Area printer allows us to update a specific area of the console output.
// The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 10 times to update the area with the current time.
for i := 0; i < 10; i++ {
// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
// The Srender() function is used to save the BigText as a string.
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
// Update the Area contents with the current time string.
area.Update(str)
// Sleep for a second before the next update.
time.Sleep(time.Second)
}
// Stop the Area printer after all updates are done.
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/demo/animation.svg 0000664 0000000 0000000 00000054317 14650106263 0025221 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/demo/main.go 0000664 0000000 0000000 00000002517 14650106263 0023767 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print an informational message using PTerm's Info printer.
// This message will stay in place while the area updates.
pterm.Info.Println("The previous text will stay in place, while the area updates.")
// Print two new lines as spacer.
pterm.Print("\n\n")
// Start the Area printer from PTerm's DefaultArea, with the Center option.
// The Area printer allows us to update a specific area of the console output.
// The returned 'area' object is used to control the area updates.
area, _ := pterm.DefaultArea.WithCenter().Start()
// Loop 10 times to update the area with the current time.
for i := 0; i < 10; i++ {
// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
// The Srender() function is used to save the BigText as a string.
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()
// Update the Area contents with the current time string.
area.Update(str)
// Sleep for a second before the next update.
time.Sleep(time.Second)
}
// Stop the Area printer after all updates are done.
area.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/area/dynamic-chart/ 0000775 0000000 0000000 00000000000 14650106263 0024306 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/dynamic-chart/README.md 0000664 0000000 0000000 00000002454 14650106263 0025572 0 ustar 00root root 0000000 0000000 # area/dynamic-chart
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen centered area.
// This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Ensure the area stops updating when we're done.
defer area.Stop()
// Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
// Create a new bar chart with dynamic bars.
// The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
// Render the bar chart to a string.
// This string will be used to update the area.
content, _ := barchart.Srender()
// Update the area with the new bar chart.
area.Update(content)
// Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
{Label: "A", Value: 10}, // A static bar.
{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
{Label: "C", Value: 30}, // Another static bar.
{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/dynamic-chart/animation.svg 0000664 0000000 0000000 00000120322 14650106263 0027006 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/dynamic-chart/main.go 0000664 0000000 0000000 00000002356 14650106263 0025567 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen centered area.
// This area will be used to display the bar chart.
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Ensure the area stops updating when we're done.
defer area.Stop()
// Loop to update the bar chart 10 times.
for i := 0; i < 10; i++ {
// Create a new bar chart with dynamic bars.
// The bars will change based on the current iteration.
barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
// Render the bar chart to a string.
// This string will be used to update the area.
content, _ := barchart.Srender()
// Update the area with the new bar chart.
area.Update(content)
// Wait for half a second before the next update.
time.Sleep(500 * time.Millisecond)
}
}
// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
return pterm.Bars{
{Label: "A", Value: 10}, // A static bar.
{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
{Label: "C", Value: 30}, // Another static bar.
{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
}
}
golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen-center/ 0000775 0000000 0000000 00000000000 14650106263 0025203 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen-center/README.md 0000664 0000000 0000000 00000001523 14650106263 0026463 0 ustar 00root root 0000000 0000000 # area/fullscreen-center
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Initialize a new PTerm area with fullscreen and center options
// The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
// Update the content of the area with the current count
// The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second
time.Sleep(time.Second)
}
// Stop the area after all updates are done
// This will clear the area and return the terminal to its normal state
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen-center/animation.svg 0000664 0000000 0000000 00000016701 14650106263 0027710 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen-center/main.go 0000664 0000000 0000000 00000001421 14650106263 0026454 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Initialize a new PTerm area with fullscreen and center options
// The Start() function returns the created area and an error (ignored here)
area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
// Loop 5 times to demonstrate dynamic content update
for i := 0; i < 5; i++ {
// Update the content of the area with the current count
// The Sprintf function is used to format the string with the count
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second
time.Sleep(time.Second)
}
// Stop the area after all updates are done
// This will clear the area and return the terminal to its normal state
area.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen/ 0000775 0000000 0000000 00000000000 14650106263 0023725 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen/README.md 0000664 0000000 0000000 00000001354 14650106263 0025207 0 ustar 00root root 0000000 0000000 # area/fullscreen
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen area. This will return an area instance and an error.
// The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
// Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen/animation.svg 0000664 0000000 0000000 00000021014 14650106263 0026423 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/area/fullscreen/main.go 0000664 0000000 0000000 00000001261 14650106263 0025200 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Start a new fullscreen area. This will return an area instance and an error.
// The underscore (_) is used to ignore the error.
area, _ := pterm.DefaultArea.WithFullscreen().Start()
// Loop 5 times to update the area content.
for i := 0; i < 5; i++ {
// Update the content of the area with the current count.
// The Sprintf function is used to format the string.
area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))
// Pause for a second before the next update.
time.Sleep(time.Second)
}
// Stop the area after all updates are done.
area.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/ 0000775 0000000 0000000 00000000000 14650106263 0022441 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/README.md 0000664 0000000 0000000 00000022036 14650106263 0023723 0 ustar 00root root 0000000 0000000 ### barchart/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the bars for the chart
bars := []pterm.Bar{
{Label: "Bar 1", Value: 5},
{Label: "Bar 2", Value: 3},
{Label: "Longer Label", Value: 7},
}
// Print an informational message
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
// Create a bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithBars(bars).Render()
// Create a horizontal bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
```
### barchart/custom-height
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of Bar structs. Each struct represents a bar in the chart.
// The Label field is the name of the bar and the Value field is the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create and render a bar chart with the defined bars and a height of 5.
// The WithBars method is used to set the bars of the chart.
// The WithHeight method is used to set the height of the chart.
// The Render method is used to display the chart in the terminal.
pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
```
### barchart/custom-width
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and has a width of 5
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
```
### barchart/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
// The `WithBars` method is used to set the bars of the chart.
// The `Render` method is used to display the chart.
pterm.DefaultBarChart.WithBars(bars).Render()
}
```
### barchart/horizontal
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is displayed horizontally
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
```
### barchart/horizontal-show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and displays the value of each bar
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
```
### barchart/mixed-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars for the chart.
// Each bar has a label and a value.
bars := []pterm.Bar{
{Label: "Bar 1", Value: 2},
{Label: "Bar 2", Value: -3},
{Label: "Bar 3", Value: -2},
{Label: "Bar 4", Value: 5},
{Label: "Longer Label", Value: 7},
}
// Print a section header.
// This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
// Create a bar chart with the defined bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
```
### barchart/negative-values
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars with negative values.
// Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
{Label: "Bar 1", Value: -5},
{Label: "Bar 2", Value: -3},
{Label: "Longer Label", Value: -7},
}
// Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
// Create a vertical bar chart with the defined bars.
// The WithShowValue() option is used to display the value of each bar in the chart.
// The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The WithHorizontal() option is used to orient the chart horizontally.
// The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
```
### barchart/show-value
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of bars for the bar chart. Each bar is represented by a struct
// with a Label and a Value. The Label is a string that represents the name of the bar,
// and the Value is an integer that represents the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
// Chain the WithBars method to set the bars of the chart.
// Chain the WithShowValue method to display the value of each bar on the chart.
// Finally, call the Render method to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-height/ 0000775 0000000 0000000 00000000000 14650106263 0025221 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-height/README.md 0000664 0000000 0000000 00000001601 14650106263 0026476 0 ustar 00root root 0000000 0000000 # barchart/custom-height
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of Bar structs. Each struct represents a bar in the chart.
// The Label field is the name of the bar and the Value field is the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create and render a bar chart with the defined bars and a height of 5.
// The WithBars method is used to set the bars of the chart.
// The WithHeight method is used to set the height of the chart.
// The Render method is used to display the chart in the terminal.
pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-height/animation.svg 0000664 0000000 0000000 00000010415 14650106263 0027722 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-height/main.go 0000664 0000000 0000000 00000001477 14650106263 0026505 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of Bar structs. Each struct represents a bar in the chart.
// The Label field is the name of the bar and the Value field is the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create and render a bar chart with the defined bars and a height of 5.
// The WithBars method is used to set the bars of the chart.
// The WithHeight method is used to set the height of the chart.
// The Render method is used to display the chart in the terminal.
pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-width/ 0000775 0000000 0000000 00000000000 14650106263 0025070 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-width/README.md 0000664 0000000 0000000 00000001235 14650106263 0026350 0 ustar 00root root 0000000 0000000 # barchart/custom-width
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and has a width of 5
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-width/animation.svg 0000664 0000000 0000000 00000007045 14650106263 0027576 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/custom-width/main.go 0000664 0000000 0000000 00000001134 14650106263 0026342 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and has a width of 5
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/default/ 0000775 0000000 0000000 00000000000 14650106263 0024065 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/default/README.md 0000664 0000000 0000000 00000001501 14650106263 0025341 0 ustar 00root root 0000000 0000000 # barchart/default
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
// The `WithBars` method is used to set the bars of the chart.
// The `Render` method is used to display the chart.
pterm.DefaultBarChart.WithBars(bars).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/default/animation.svg 0000664 0000000 0000000 00000012150 14650106263 0026564 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/default/main.go 0000664 0000000 0000000 00000001405 14650106263 0025340 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
// The `WithBars` method is used to set the bars of the chart.
// The `Render` method is used to display the chart.
pterm.DefaultBarChart.WithBars(bars).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023365 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/demo/README.md 0000664 0000000 0000000 00000001767 14650106263 0024657 0 ustar 00root root 0000000 0000000 # barchart/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the bars for the chart
bars := []pterm.Bar{
{Label: "Bar 1", Value: 5},
{Label: "Bar 2", Value: 3},
{Label: "Longer Label", Value: 7},
}
// Print an informational message
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
// Create a bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithBars(bars).Render()
// Create a horizontal bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/demo/animation.svg 0000664 0000000 0000000 00000075656 14650106263 0026110 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/demo/main.go 0000664 0000000 0000000 00000001676 14650106263 0024652 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the bars for the chart
bars := []pterm.Bar{
{Label: "Bar 1", Value: 5},
{Label: "Bar 2", Value: 3},
{Label: "Longer Label", Value: 7},
}
// Print an informational message
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
// Create a bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithBars(bars).Render()
// Create a horizontal bar chart with the defined bars and render it
// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
// The Render function is then called to display the chart
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal-show-value/ 0000775 0000000 0000000 00000000000 14650106263 0026722 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal-show-value/README.md 0000664 0000000 0000000 00000001267 14650106263 0030207 0 ustar 00root root 0000000 0000000 # barchart/horizontal-show-value
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and displays the value of each bar
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal-show-value/animation.svg 0000664 0000000 0000000 00000012034 14650106263 0031422 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal-show-value/main.go 0000664 0000000 0000000 00000001155 14650106263 0030177 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
barData := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is horizontal and displays the value of each bar
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal/ 0000775 0000000 0000000 00000000000 14650106263 0024632 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal/README.md 0000664 0000000 0000000 00000001177 14650106263 0026117 0 ustar 00root root 0000000 0000000 # barchart/horizontal
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is displayed horizontally
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal/animation.svg 0000664 0000000 0000000 00000011062 14650106263 0027332 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/horizontal/main.go 0000664 0000000 0000000 00000001100 14650106263 0026075 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the bar chart
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined data
// The chart is displayed horizontally
// The Render() function is called to display the chart
pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/mixed-values/ 0000775 0000000 0000000 00000000000 14650106263 0025044 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/mixed-values/README.md 0000664 0000000 0000000 00000002141 14650106263 0026321 0 ustar 00root root 0000000 0000000 # barchart/mixed-values
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars for the chart.
// Each bar has a label and a value.
bars := []pterm.Bar{
{Label: "Bar 1", Value: 2},
{Label: "Bar 2", Value: -3},
{Label: "Bar 3", Value: -2},
{Label: "Bar 4", Value: 5},
{Label: "Longer Label", Value: 7},
}
// Print a section header.
// This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
// Create a bar chart with the defined bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/mixed-values/animation.svg 0000664 0000000 0000000 00000030275 14650106263 0027553 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/mixed-values/main.go 0000664 0000000 0000000 00000002040 14650106263 0026313 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars for the chart.
// Each bar has a label and a value.
bars := []pterm.Bar{
{Label: "Bar 1", Value: 2},
{Label: "Bar 2", Value: -3},
{Label: "Bar 3", Value: -2},
{Label: "Bar 4", Value: 5},
{Label: "Longer Label", Value: 7},
}
// Print a section header.
// This is useful for separating different parts of the output.
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
// Create a bar chart with the defined bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The chart will display the value of each bar.
// The Render() function is called to display the chart.
pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/negative-values/ 0000775 0000000 0000000 00000000000 14650106263 0025540 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/negative-values/README.md 0000664 0000000 0000000 00000002120 14650106263 0027012 0 ustar 00root root 0000000 0000000 # barchart/negative-values
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars with negative values.
// Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
{Label: "Bar 1", Value: -5},
{Label: "Bar 2", Value: -3},
{Label: "Longer Label", Value: -7},
}
// Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
// Create a vertical bar chart with the defined bars.
// The WithShowValue() option is used to display the value of each bar in the chart.
// The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The WithHorizontal() option is used to orient the chart horizontally.
// The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/negative-values/animation.svg 0000664 0000000 0000000 00000027502 14650106263 0030246 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/negative-values/main.go 0000664 0000000 0000000 00000002014 14650106263 0027010 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a set of bars with negative values.
// Each bar is represented by a struct with a label and a value.
negativeBars := pterm.Bars{
{Label: "Bar 1", Value: -5},
{Label: "Bar 2", Value: -3},
{Label: "Longer Label", Value: -7},
}
// Print an informational message to the console.
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
// Create a vertical bar chart with the defined bars.
// The WithShowValue() option is used to display the value of each bar in the chart.
// The Render() method is called to draw the chart.
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
// Create a horizontal bar chart with the same bars.
// The WithHorizontal() option is used to orient the chart horizontally.
// The WithShowValue() option and Render() method are used in the same way as before.
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/barchart/show-value/ 0000775 0000000 0000000 00000000000 14650106263 0024533 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/show-value/README.md 0000664 0000000 0000000 00000001736 14650106263 0026021 0 ustar 00root root 0000000 0000000 # barchart/show-value
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of bars for the bar chart. Each bar is represented by a struct
// with a Label and a Value. The Label is a string that represents the name of the bar,
// and the Value is an integer that represents the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
// Chain the WithBars method to set the bars of the chart.
// Chain the WithShowValue method to display the value of each bar on the chart.
// Finally, call the Render method to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/barchart/show-value/animation.svg 0000664 0000000 0000000 00000013243 14650106263 0027236 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/barchart/show-value/main.go 0000664 0000000 0000000 00000001637 14650106263 0026015 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define a slice of bars for the bar chart. Each bar is represented by a struct
// with a Label and a Value. The Label is a string that represents the name of the bar,
// and the Value is an integer that represents the height of the bar.
bars := []pterm.Bar{
{Label: "A", Value: 10},
{Label: "B", Value: 20},
{Label: "C", Value: 30},
{Label: "D", Value: 40},
{Label: "E", Value: 50},
{Label: "F", Value: 40},
{Label: "G", Value: 30},
{Label: "H", Value: 20},
{Label: "I", Value: 10},
}
// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
// Chain the WithBars method to set the bars of the chart.
// Chain the WithShowValue method to display the value of each bar on the chart.
// Finally, call the Render method to display the chart.
pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/basictext/ 0000775 0000000 0000000 00000000000 14650106263 0022641 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/basictext/README.md 0000664 0000000 0000000 00000001447 14650106263 0024126 0 ustar 00root root 0000000 0000000 ### basictext/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// The DefaultBasicText is a basic text printer provided by PTerm.
// It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
// The DefaultBasicText can be used in any context that requires a TextPrinter.
// Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
// The DefaultBasicText is also useful for resolving progress bars and spinners.
}
```
golang-github-pterm-pterm-0.12.79/_examples/basictext/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023565 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/basictext/demo/README.md 0000664 0000000 0000000 00000001237 14650106263 0025047 0 ustar 00root root 0000000 0000000 # basictext/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// The DefaultBasicText is a basic text printer provided by PTerm.
// It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
// The DefaultBasicText can be used in any context that requires a TextPrinter.
// Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
// The DefaultBasicText is also useful for resolving progress bars and spinners.
}
```
golang-github-pterm-pterm-0.12.79/_examples/basictext/demo/animation.svg 0000664 0000000 0000000 00000005025 14650106263 0026267 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/basictext/demo/main.go 0000664 0000000 0000000 00000001145 14650106263 0025041 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// The DefaultBasicText is a basic text printer provided by PTerm.
// It is used to print text without any special formatting.
pterm.DefaultBasicText.Println("Default basic text printer.")
// The DefaultBasicText can be used in any context that requires a TextPrinter.
// Here, we're using it with the LightMagenta function to color a portion of the text.
pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
// The DefaultBasicText is also useful for resolving progress bars and spinners.
}
golang-github-pterm-pterm-0.12.79/_examples/bigtext/ 0000775 0000000 0000000 00000000000 14650106263 0022321 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/README.md 0000664 0000000 0000000 00000004577 14650106263 0023615 0 ustar 00root root 0000000 0000000 ### bigtext/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Create a large text with the LetterStyle from the standard theme.
// This is useful for creating title screens.
pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
// Create a large text with differently colored letters.
// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
// This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
).Render()
// Create a large text with a specific RGB color.
// This can be used when you need a specific color that is not available in the standard colors.
// Here, the color is gold (RGB: 255, 215, 0).
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
).Render()
}
```
### bigtext/colored
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Initialize a big text display with the letters "P" and "Term"
// "P" is displayed in cyan and "Term" is displayed in light magenta
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
Render() // Render the big text to the terminal
}
```
### bigtext/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define the text to be rendered
var text = "PTerm"
// Convert the text into a format suitable for PTerm
var letters = putils.LettersFromString(text)
// Render the text using PTerm's default big text style
pterm.DefaultBigText.WithLetters(letters).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bigtext/colored/ 0000775 0000000 0000000 00000000000 14650106263 0023750 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/colored/README.md 0000664 0000000 0000000 00000001015 14650106263 0025224 0 ustar 00root root 0000000 0000000 # bigtext/colored
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Initialize a big text display with the letters "P" and "Term"
// "P" is displayed in cyan and "Term" is displayed in light magenta
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
Render() // Render the big text to the terminal
}
```
golang-github-pterm-pterm-0.12.79/_examples/bigtext/colored/animation.svg 0000664 0000000 0000000 00000010431 14650106263 0026447 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/colored/main.go 0000664 0000000 0000000 00000000722 14650106263 0025224 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Initialize a big text display with the letters "P" and "Term"
// "P" is displayed in cyan and "Term" is displayed in light magenta
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
Render() // Render the big text to the terminal
}
golang-github-pterm-pterm-0.12.79/_examples/bigtext/default/ 0000775 0000000 0000000 00000000000 14650106263 0023745 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/default/README.md 0000664 0000000 0000000 00000000652 14650106263 0025227 0 ustar 00root root 0000000 0000000 # bigtext/default
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define the text to be rendered
var text = "PTerm"
// Convert the text into a format suitable for PTerm
var letters = putils.LettersFromString(text)
// Render the text using PTerm's default big text style
pterm.DefaultBigText.WithLetters(letters).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bigtext/default/animation.svg 0000664 0000000 0000000 00000010312 14650106263 0026442 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/default/main.go 0000664 0000000 0000000 00000000557 14650106263 0025227 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define the text to be rendered
var text = "PTerm"
// Convert the text into a format suitable for PTerm
var letters = putils.LettersFromString(text)
// Render the text using PTerm's default big text style
pterm.DefaultBigText.WithLetters(letters).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/bigtext/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023245 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/demo/README.md 0000664 0000000 0000000 00000002060 14650106263 0024522 0 ustar 00root root 0000000 0000000 # bigtext/demo
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Create a large text with the LetterStyle from the standard theme.
// This is useful for creating title screens.
pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
// Create a large text with differently colored letters.
// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
// This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
).Render()
// Create a large text with a specific RGB color.
// This can be used when you need a specific color that is not available in the standard colors.
// Here, the color is gold (RGB: 255, 215, 0).
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bigtext/demo/animation.svg 0000664 0000000 0000000 00000023023 14650106263 0025745 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bigtext/demo/main.go 0000664 0000000 0000000 00000001770 14650106263 0024525 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Create a large text with the LetterStyle from the standard theme.
// This is useful for creating title screens.
pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()
// Create a large text with differently colored letters.
// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
// This can be used to highlight specific parts of the text.
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
).Render()
// Create a large text with a specific RGB color.
// This can be used when you need a specific color that is not available in the standard colors.
// Here, the color is gold (RGB: 255, 215, 0).
pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/box/ 0000775 0000000 0000000 00000000000 14650106263 0021443 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/README.md 0000664 0000000 0000000 00000010242 14650106263 0022721 0 ustar 00root root 0000000 0000000 ### box/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print an informational message.
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
// Create three panels with text, some of them with titles.
// The panels are created using the DefaultBox style.
panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
// Combine the panels into a layout using the DefaultPanel style.
// The layout is a 2D grid, with each row being an array of panels.
// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
{{Data: panel1}, {Data: panel2}},
{{Data: panel3}},
}).Srender()
// Print the panels layout inside a box with a title.
// The box is created using the DefaultBox style, with the title positioned at the bottom right.
pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
```
### box/custom-padding
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with custom padding options and print "Hello, World!" inside it.
pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
```
### box/default
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with PTerm and print a message in it.
// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
pterm.DefaultBox.Println("Hello, World!")
}
```
### box/title
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
// Define a title for the box
title := pterm.LightRed("I'm a box!")
// Create boxes with the title positioned differently and containing different content
box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
// Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
{{box7}},
}).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/box/custom-padding/ 0000775 0000000 0000000 00000000000 14650106263 0024361 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/custom-padding/README.md 0000664 0000000 0000000 00000000522 14650106263 0025637 0 ustar 00root root 0000000 0000000 # box/custom-padding
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with custom padding options and print "Hello, World!" inside it.
pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/box/custom-padding/animation.svg 0000664 0000000 0000000 00000006017 14650106263 0027065 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/custom-padding/main.go 0000664 0000000 0000000 00000000424 14650106263 0025634 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with custom padding options and print "Hello, World!" inside it.
pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}
golang-github-pterm-pterm-0.12.79/_examples/box/default/ 0000775 0000000 0000000 00000000000 14650106263 0023067 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/default/README.md 0000664 0000000 0000000 00000000477 14650106263 0024356 0 ustar 00root root 0000000 0000000 # box/default
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with PTerm and print a message in it.
// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
pterm.DefaultBox.Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/box/default/animation.svg 0000664 0000000 0000000 00000004743 14650106263 0025577 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/default/main.go 0000664 0000000 0000000 00000000410 14650106263 0024335 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with PTerm and print a message in it.
// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
pterm.DefaultBox.Println("Hello, World!")
}
golang-github-pterm-pterm-0.12.79/_examples/box/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022367 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/demo/README.md 0000664 0000000 0000000 00000003141 14650106263 0023645 0 ustar 00root root 0000000 0000000 # box/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print an informational message.
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
// Create three panels with text, some of them with titles.
// The panels are created using the DefaultBox style.
panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
// Combine the panels into a layout using the DefaultPanel style.
// The layout is a 2D grid, with each row being an array of panels.
// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
{{Data: panel1}, {Data: panel2}},
{{Data: panel3}},
}).Srender()
// Print the panels layout inside a box with a title.
// The box is created using the DefaultBox style, with the title positioned at the bottom right.
pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
```
golang-github-pterm-pterm-0.12.79/_examples/box/demo/animation.svg 0000664 0000000 0000000 00000107020 14650106263 0025067 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/demo/main.go 0000664 0000000 0000000 00000003055 14650106263 0023645 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Print an informational message.
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")
// Create three panels with text, some of them with titles.
// The panels are created using the DefaultBox style.
panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")
// Combine the panels into a layout using the DefaultPanel style.
// The layout is a 2D grid, with each row being an array of panels.
// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
{{Data: panel1}, {Data: panel2}},
{{Data: panel3}},
}).Srender()
// Print the panels layout inside a box with a title.
// The box is created using the DefaultBox style, with the title positioned at the bottom right.
pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
golang-github-pterm-pterm-0.12.79/_examples/box/title/ 0000775 0000000 0000000 00000000000 14650106263 0022564 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/title/README.md 0000664 0000000 0000000 00000002632 14650106263 0024046 0 ustar 00root root 0000000 0000000 # box/title
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
// Define a title for the box
title := pterm.LightRed("I'm a box!")
// Create boxes with the title positioned differently and containing different content
box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
// Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
{{box7}},
}).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/box/title/animation.svg 0000664 0000000 0000000 00000021775 14650106263 0025300 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/box/title/main.go 0000664 0000000 0000000 00000002545 14650106263 0024045 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a default box with specified padding
paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)
// Define a title for the box
title := pterm.LightRed("I'm a box!")
// Create boxes with the title positioned differently and containing different content
box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n 1") // Title at default position (top left)
box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n 2") // Title at top center
box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n 3") // Title at top right
box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n 4") // Title at bottom right
box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n 5") // Title at bottom center
box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n 6") // Title at bottom left
box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n 7") // Title at top left
// Render the boxes in a panel layout
pterm.DefaultPanel.WithPanels([][]pterm.Panel{
{{box1}, {box2}, {box3}},
{{box4}, {box5}, {box6}},
{{box7}},
}).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/bulletlist/ 0000775 0000000 0000000 00000000000 14650106263 0023036 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bulletlist/README.md 0000664 0000000 0000000 00000004501 14650106263 0024315 0 ustar 00root root 0000000 0000000 ### bulletlist/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a list of bullet list items with different levels.
bulletListItems := []pterm.BulletListItem{
{Level: 0, Text: "Level 0"}, // Level 0 item
{Level: 1, Text: "Level 1"}, // Level 1 item
{Level: 2, Text: "Level 2"}, // Level 2 item
}
// Use the default bullet list style to render the list items.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
// Define a string with different levels of indentation.
text := `0
1
2
3`
// Convert the indented string to a bullet list and render it.
putils.BulletListFromString(text, " ").Render()
}
```
### bulletlist/customized
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a list of bullet list items with different styles and levels.
bulletListItems := []pterm.BulletListItem{
{
Level: 0, // Level 0 (top level)
Text: "Blue", // Text to display
TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
},
{
Level: 1, // Level 1 (sub-item)
Text: "Green", // Text to display
TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
Bullet: "-", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
},
{
Level: 2, // Level 2 (sub-sub-item)
Text: "Cyan", // Text to display
TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
Bullet: ">", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
},
}
// Create a bullet list with the defined items and render it.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bulletlist/customized/ 0000775 0000000 0000000 00000000000 14650106263 0025224 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bulletlist/customized/README.md 0000664 0000000 0000000 00000002513 14650106263 0026504 0 ustar 00root root 0000000 0000000 # bulletlist/customized
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a list of bullet list items with different styles and levels.
bulletListItems := []pterm.BulletListItem{
{
Level: 0, // Level 0 (top level)
Text: "Blue", // Text to display
TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
},
{
Level: 1, // Level 1 (sub-item)
Text: "Green", // Text to display
TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
Bullet: "-", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
},
{
Level: 2, // Level 2 (sub-sub-item)
Text: "Cyan", // Text to display
TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
Bullet: ">", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
},
}
// Create a bullet list with the defined items and render it.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bulletlist/customized/animation.svg 0000664 0000000 0000000 00000005152 14650106263 0027727 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bulletlist/customized/main.go 0000664 0000000 0000000 00000002412 14650106263 0026476 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a list of bullet list items with different styles and levels.
bulletListItems := []pterm.BulletListItem{
{
Level: 0, // Level 0 (top level)
Text: "Blue", // Text to display
TextStyle: pterm.NewStyle(pterm.FgBlue), // Text color
BulletStyle: pterm.NewStyle(pterm.FgRed), // Bullet color
},
{
Level: 1, // Level 1 (sub-item)
Text: "Green", // Text to display
TextStyle: pterm.NewStyle(pterm.FgGreen), // Text color
Bullet: "-", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
},
{
Level: 2, // Level 2 (sub-sub-item)
Text: "Cyan", // Text to display
TextStyle: pterm.NewStyle(pterm.FgCyan), // Text color
Bullet: ">", // Custom bullet symbol
BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
},
}
// Create a bullet list with the defined items and render it.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/bulletlist/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023762 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bulletlist/demo/README.md 0000664 0000000 0000000 00000001336 14650106263 0025244 0 ustar 00root root 0000000 0000000 # bulletlist/demo
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a list of bullet list items with different levels.
bulletListItems := []pterm.BulletListItem{
{Level: 0, Text: "Level 0"}, // Level 0 item
{Level: 1, Text: "Level 1"}, // Level 1 item
{Level: 2, Text: "Level 2"}, // Level 2 item
}
// Use the default bullet list style to render the list items.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
// Define a string with different levels of indentation.
text := `0
1
2
3`
// Convert the indented string to a bullet list and render it.
putils.BulletListFromString(text, " ").Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/bulletlist/demo/animation.svg 0000664 0000000 0000000 00000006716 14650106263 0026474 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/bulletlist/demo/main.go 0000664 0000000 0000000 00000001243 14650106263 0025235 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a list of bullet list items with different levels.
bulletListItems := []pterm.BulletListItem{
{Level: 0, Text: "Level 0"}, // Level 0 item
{Level: 1, Text: "Level 1"}, // Level 1 item
{Level: 2, Text: "Level 2"}, // Level 2 item
}
// Use the default bullet list style to render the list items.
pterm.DefaultBulletList.WithItems(bulletListItems).Render()
// Define a string with different levels of indentation.
text := `0
1
2
3`
// Convert the indented string to a bullet list and render it.
putils.BulletListFromString(text, " ").Render()
}
golang-github-pterm-pterm-0.12.79/_examples/center/ 0000775 0000000 0000000 00000000000 14650106263 0022133 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/center/README.md 0000664 0000000 0000000 00000001567 14650106263 0023423 0 ustar 00root root 0000000 0000000 ### center/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print a block of text centered in the terminal
pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
// Generate BigLetters and store in 's'
s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
// Print the BigLetters 's' centered in the terminal
pterm.DefaultCenter.Println(s)
// Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
```
golang-github-pterm-pterm-0.12.79/_examples/center/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023057 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/center/demo/README.md 0000664 0000000 0000000 00000001362 14650106263 0024340 0 ustar 00root root 0000000 0000000 # center/demo
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print a block of text centered in the terminal
pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
// Generate BigLetters and store in 's'
s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
// Print the BigLetters 's' centered in the terminal
pterm.DefaultCenter.Println(s)
// Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
```
golang-github-pterm-pterm-0.12.79/_examples/center/demo/animation.svg 0000664 0000000 0000000 00000015222 14650106263 0025561 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/center/demo/main.go 0000664 0000000 0000000 00000001273 14650106263 0024335 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Print a block of text centered in the terminal
pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")
// Generate BigLetters and store in 's'
s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()
// Print the BigLetters 's' centered in the terminal
pterm.DefaultCenter.Println(s)
// Print each line of the text separately centered in the terminal
pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/ 0000775 0000000 0000000 00000000000 14650106263 0022467 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/README.md 0000664 0000000 0000000 00000025135 14650106263 0023754 0 ustar 00root root 0000000 0000000 ### coloring/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
}).Render() // Render the table.
pterm.Println()
// Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
// Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
// Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
```
### coloring/disable-output
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
// At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
// At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
// Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
```
### coloring/fade-colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
// Define the start and end points for the color gradient.
startColor := pterm.NewRGB(0, 255, 255) // Cyan
endColor := pterm.NewRGB(255, 0, 255) // Magenta
// Get the terminal height to determine the gradient range.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the range of the terminal height to create a color gradient.
for i := 0; i < terminalHeight-2; i++ {
// Calculate the fade factor for the current step in the gradient.
fadeFactor := float32(i) / float32(terminalHeight-2)
// Create a color that represents the current step in the gradient.
currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
// Print a string with the current color.
currentColor.Println("Hello, World!")
}
}
```
### coloring/fade-colors-rgb-style
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors
white := pterm.NewRGB(255, 255, 255)
grey := pterm.NewRGB(128, 128, 128)
black := pterm.NewRGB(0, 0, 0)
red := pterm.NewRGB(255, 0, 0)
purple := pterm.NewRGB(255, 0, 255)
green := pterm.NewRGB(0, 255, 0)
// Define strings to be printed
str1 := "RGB colors only work in Terminals which support TrueColor."
str2 := "The background and foreground colors can be customized individually."
str3 := "Styles can also be applied. For example: Bold or Italic."
// Print first string with color fading from white to purple
printFadedString(str1, white, purple, grey, black)
// Print second string with color fading from purple to red
printFadedString(str2, black, purple, red, red)
// Print third string with color fading from white to green and style changes
printStyledString(str3, white, green, red, black)
}
// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
boldStr := strings.Split("Bold", "")
italicStr := strings.Split("Italic", "")
bold, italic := 0, 0
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Check if the next letters are "Bold" or "Italic" and add the corresponding style
if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
style = style.AddOptions(pterm.Bold)
bold++
} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
style = style.AddOptions(pterm.Italic)
italic++
}
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
```
### coloring/fade-multiple-colors
SHOW SOURCE
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB values for gradient points.
startColor := pterm.NewRGB(0, 255, 255)
firstPoint := pterm.NewRGB(255, 0, 255)
secondPoint := pterm.NewRGB(255, 0, 0)
thirdPoint := pterm.NewRGB(0, 255, 0)
endColor := pterm.NewRGB(255, 255, 255)
// Define the string to be printed.
str := "RGB colors only work in Terminals which support TrueColor."
strs := strings.Split(str, "")
// Initialize an empty string for the faded info.
var fadeInfo string
// Loop over the string length to create a gradient effect.
for i := 0; i < len(str); i++ {
// Append each character of the string with a faded color to the info string.
fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
// Print the info string with gradient effect.
pterm.Info.Println(fadeInfo)
// Get the terminal height.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the terminal height to print "Hello, World!" with a gradient effect.
for i := 0; i < terminalHeight-2; i++ {
// Print the string with a color that fades from startColor to endColor.
startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
}
}
```
### coloring/override-default-printers
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default error message with PTerm's built-in Error style.
pterm.Error.Println("This is the default Error")
// Override the default error prefix with a new text and style.
pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
// Print the error message again, this time with the overridden prefix.
pterm.Error.Println("This is the default Error after the prefix was overridden")
}
```
### coloring/print-color-rgb
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a new RGB color with values 178, 44, 199.
// This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 15, 199, 209.
// This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 201, 144, 30.
// This color will be used for the background.
// The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
```
### coloring/print-color-rgb-style
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors for foreground and background.
foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
// Create a new RGB style with the defined foreground and background colors.
rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
// Print a string with the custom RGB style.
rgbStyle.Println("This text is not styled.")
// Add the 'Bold' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
// Add the 'Italic' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023413 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/demo/README.md 0000664 0000000 0000000 00000003602 14650106263 0024673 0 ustar 00root root 0000000 0000000 # coloring/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
}).Render() // Render the table.
pterm.Println()
// Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
// Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
// Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/demo/animation.svg 0000664 0000000 0000000 00000020141 14650106263 0026111 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/demo/main.go 0000664 0000000 0000000 00000003511 14650106263 0024666 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a table with different foreground and background colors.
pterm.DefaultTable.WithData([][]string{
{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
}).Render() // Render the table.
pterm.Println()
// Print words in different colors.
pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))
pterm.Println()
// Create a new style with a red background, light green foreground, and bold text.
style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
// Print text using the created style.
style.Println("This text uses a style and is bold and light green with a red background!")
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/disable-output/ 0000775 0000000 0000000 00000000000 14650106263 0025430 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/disable-output/README.md 0000664 0000000 0000000 00000001121 14650106263 0026702 0 ustar 00root root 0000000 0000000 # coloring/disable-output
```go
package main
import "github.com/pterm/pterm"
func main() {
// Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
// At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
// At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
// Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/disable-output/animation.svg 0000664 0000000 0000000 00000012643 14650106263 0030136 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/disable-output/main.go 0000664 0000000 0000000 00000001016 14650106263 0026701 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Loop from 0 to 14
for i := 0; i < 15; i++ {
switch i {
case 5:
// At the 5th iteration, print a message and disable the output
pterm.Info.Println("Disabled Output!")
pterm.DisableOutput()
case 10:
// At the 10th iteration, enable the output and print a message
pterm.EnableOutput()
pterm.Info.Println("Enabled Output!")
}
// Print a progress message for each iteration
pterm.Printf("Printing something... [%d/%d]\n", i, 15)
}
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors-rgb-style/ 0000775 0000000 0000000 00000000000 14650106263 0026573 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors-rgb-style/README.md 0000664 0000000 0000000 00000005130 14650106263 0030051 0 ustar 00root root 0000000 0000000 # coloring/fade-colors-rgb-style
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors
white := pterm.NewRGB(255, 255, 255)
grey := pterm.NewRGB(128, 128, 128)
black := pterm.NewRGB(0, 0, 0)
red := pterm.NewRGB(255, 0, 0)
purple := pterm.NewRGB(255, 0, 255)
green := pterm.NewRGB(0, 255, 0)
// Define strings to be printed
str1 := "RGB colors only work in Terminals which support TrueColor."
str2 := "The background and foreground colors can be customized individually."
str3 := "Styles can also be applied. For example: Bold or Italic."
// Print first string with color fading from white to purple
printFadedString(str1, white, purple, grey, black)
// Print second string with color fading from purple to red
printFadedString(str2, black, purple, red, red)
// Print third string with color fading from white to green and style changes
printStyledString(str3, white, green, red, black)
}
// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
boldStr := strings.Split("Bold", "")
italicStr := strings.Split("Italic", "")
bold, italic := 0, 0
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Check if the next letters are "Bold" or "Italic" and add the corresponding style
if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
style = style.AddOptions(pterm.Bold)
bold++
} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
style = style.AddOptions(pterm.Italic)
italic++
}
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors-rgb-style/animation.svg 0000664 0000000 0000000 00000116537 14650106263 0031310 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors-rgb-style/main.go 0000664 0000000 0000000 00000005016 14650106263 0030050 0 ustar 00root root 0000000 0000000 package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors
white := pterm.NewRGB(255, 255, 255)
grey := pterm.NewRGB(128, 128, 128)
black := pterm.NewRGB(0, 0, 0)
red := pterm.NewRGB(255, 0, 0)
purple := pterm.NewRGB(255, 0, 255)
green := pterm.NewRGB(0, 255, 0)
// Define strings to be printed
str1 := "RGB colors only work in Terminals which support TrueColor."
str2 := "The background and foreground colors can be customized individually."
str3 := "Styles can also be applied. For example: Bold or Italic."
// Print first string with color fading from white to purple
printFadedString(str1, white, purple, grey, black)
// Print second string with color fading from purple to red
printFadedString(str2, black, purple, red, red)
// Print third string with color fading from white to green and style changes
printStyledString(str3, white, green, red, black)
}
// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
strs := strings.Split(str, "")
var result string
boldStr := strings.Split("Bold", "")
italicStr := strings.Split("Italic", "")
bold, italic := 0, 0
for i := 0; i < len(str); i++ {
// Create a style with color fading effect
style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
// Check if the next letters are "Bold" or "Italic" and add the corresponding style
if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
style = style.AddOptions(pterm.Bold)
bold++
} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
style = style.AddOptions(pterm.Italic)
italic++
}
// Append styled letter to result string
result += style.Sprint(strs[i])
}
pterm.Println(result)
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors/ 0000775 0000000 0000000 00000000000 14650106263 0024665 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors/README.md 0000664 0000000 0000000 00000001725 14650106263 0026151 0 ustar 00root root 0000000 0000000 # coloring/fade-colors
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
// Define the start and end points for the color gradient.
startColor := pterm.NewRGB(0, 255, 255) // Cyan
endColor := pterm.NewRGB(255, 0, 255) // Magenta
// Get the terminal height to determine the gradient range.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the range of the terminal height to create a color gradient.
for i := 0; i < terminalHeight-2; i++ {
// Calculate the fade factor for the current step in the gradient.
fadeFactor := float32(i) / float32(terminalHeight-2)
// Create a color that represents the current step in the gradient.
currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
// Print a string with the current color.
currentColor.Println("Hello, World!")
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors/animation.svg 0000664 0000000 0000000 00000017655 14650106263 0027403 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-colors/main.go 0000664 0000000 0000000 00000001625 14650106263 0026144 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Print an informational message.
pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")
// Define the start and end points for the color gradient.
startColor := pterm.NewRGB(0, 255, 255) // Cyan
endColor := pterm.NewRGB(255, 0, 255) // Magenta
// Get the terminal height to determine the gradient range.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the range of the terminal height to create a color gradient.
for i := 0; i < terminalHeight-2; i++ {
// Calculate the fade factor for the current step in the gradient.
fadeFactor := float32(i) / float32(terminalHeight-2)
// Create a color that represents the current step in the gradient.
currentColor := startColor.Fade(0, 1, fadeFactor, endColor)
// Print a string with the current color.
currentColor.Println("Hello, World!")
}
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-multiple-colors/ 0000775 0000000 0000000 00000000000 14650106263 0026516 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-multiple-colors/README.md 0000664 0000000 0000000 00000002531 14650106263 0027776 0 ustar 00root root 0000000 0000000 # coloring/fade-multiple-colors
```go
package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB values for gradient points.
startColor := pterm.NewRGB(0, 255, 255)
firstPoint := pterm.NewRGB(255, 0, 255)
secondPoint := pterm.NewRGB(255, 0, 0)
thirdPoint := pterm.NewRGB(0, 255, 0)
endColor := pterm.NewRGB(255, 255, 255)
// Define the string to be printed.
str := "RGB colors only work in Terminals which support TrueColor."
strs := strings.Split(str, "")
// Initialize an empty string for the faded info.
var fadeInfo string
// Loop over the string length to create a gradient effect.
for i := 0; i < len(str); i++ {
// Append each character of the string with a faded color to the info string.
fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
// Print the info string with gradient effect.
pterm.Info.Println(fadeInfo)
// Get the terminal height.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the terminal height to print "Hello, World!" with a gradient effect.
for i := 0; i < terminalHeight-2; i++ {
// Print the string with a color that fades from startColor to endColor.
startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-multiple-colors/animation.svg 0000664 0000000 0000000 00000027412 14650106263 0031224 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/fade-multiple-colors/main.go 0000664 0000000 0000000 00000002420 14650106263 0027767 0 ustar 00root root 0000000 0000000 package main
import (
"strings"
"github.com/pterm/pterm"
)
func main() {
// Define RGB values for gradient points.
startColor := pterm.NewRGB(0, 255, 255)
firstPoint := pterm.NewRGB(255, 0, 255)
secondPoint := pterm.NewRGB(255, 0, 0)
thirdPoint := pterm.NewRGB(0, 255, 0)
endColor := pterm.NewRGB(255, 255, 255)
// Define the string to be printed.
str := "RGB colors only work in Terminals which support TrueColor."
strs := strings.Split(str, "")
// Initialize an empty string for the faded info.
var fadeInfo string
// Loop over the string length to create a gradient effect.
for i := 0; i < len(str); i++ {
// Append each character of the string with a faded color to the info string.
fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
}
// Print the info string with gradient effect.
pterm.Info.Println(fadeInfo)
// Get the terminal height.
terminalHeight := pterm.GetTerminalHeight()
// Loop over the terminal height to print "Hello, World!" with a gradient effect.
for i := 0; i < terminalHeight-2; i++ {
// Print the string with a color that fades from startColor to endColor.
startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
}
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/override-default-printers/ 0000775 0000000 0000000 00000000000 14650106263 0027574 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/override-default-printers/README.md 0000664 0000000 0000000 00000001111 14650106263 0031045 0 ustar 00root root 0000000 0000000 # coloring/override-default-printers
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default error message with PTerm's built-in Error style.
pterm.Error.Println("This is the default Error")
// Override the default error prefix with a new text and style.
pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
// Print the error message again, this time with the overridden prefix.
pterm.Error.Println("This is the default Error after the prefix was overridden")
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/override-default-printers/animation.svg 0000664 0000000 0000000 00000006075 14650106263 0032304 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/override-default-printers/main.go 0000664 0000000 0000000 00000000773 14650106263 0031056 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Print a default error message with PTerm's built-in Error style.
pterm.Error.Println("This is the default Error")
// Override the default error prefix with a new text and style.
pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}
// Print the error message again, this time with the overridden prefix.
pterm.Error.Println("This is the default Error after the prefix was overridden")
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb-style/ 0000775 0000000 0000000 00000000000 14650106263 0026645 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb-style/README.md 0000664 0000000 0000000 00000001462 14650106263 0030127 0 ustar 00root root 0000000 0000000 # coloring/print-color-rgb-style
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors for foreground and background.
foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
// Create a new RGB style with the defined foreground and background colors.
rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
// Print a string with the custom RGB style.
rgbStyle.Println("This text is not styled.")
// Add the 'Bold' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
// Add the 'Italic' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb-style/animation.svg 0000664 0000000 0000000 00000005115 14650106263 0031347 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb-style/main.go 0000664 0000000 0000000 00000001350 14650106263 0030117 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define RGB colors for foreground and background.
foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}
// Create a new RGB style with the defined foreground and background colors.
rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)
// Print a string with the custom RGB style.
rgbStyle.Println("This text is not styled.")
// Add the 'Bold' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")
// Add the 'Italic' option to the RGB style and print a string with this style.
rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}
golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb/ 0000775 0000000 0000000 00000000000 14650106263 0025507 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb/README.md 0000664 0000000 0000000 00000001356 14650106263 0026773 0 ustar 00root root 0000000 0000000 # coloring/print-color-rgb
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a new RGB color with values 178, 44, 199.
// This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 15, 199, 209.
// This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 201, 144, 30.
// This color will be used for the background.
// The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb/animation.svg 0000664 0000000 0000000 00000006227 14650106263 0030216 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/coloring/print-color-rgb/main.go 0000664 0000000 0000000 00000001252 14650106263 0026762 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a new RGB color with values 178, 44, 199.
// This color will be used for the text.
pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 15, 199, 209.
// This color will be used for the text.
pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
// Create a new RGB color with values 201, 144, 30.
// This color will be used for the background.
// The 'true' argument indicates that the color is for the background.
pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}
golang-github-pterm-pterm-0.12.79/_examples/demo/ 0000775 0000000 0000000 00000000000 14650106263 0021577 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/demo/README.md 0000664 0000000 0000000 00000025347 14650106263 0023071 0 ustar 00root root 0000000 0000000 ### demo/demo
SHOW SOURCE
```go
package main
import (
"flag"
"math/rand"
"reflect"
"strconv"
"strings"
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
// go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second
var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
setup() // Setup the demo (flags etc.)
// Show intro
if !*skipIntro {
introScreen()
clear()
}
showcase("Structured Logging", 5, func() {
logger := pterm.DefaultLogger.
WithLevel(pterm.LogLevelTrace)
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
time.Sleep(time.Second * 3)
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
time.Sleep(time.Second * 3)
logger.Info("That was actually interesting", logger.Args("such", "wow"))
time.Sleep(time.Second * 3)
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
time.Sleep(time.Second * 3)
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
time.Sleep(time.Second * 3)
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
})
showcase("Progress bar", 2, func() {
pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
for i := 0; i < pb.Total; i++ {
pb.UpdateTitle("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])
}
pb.Increment()
time.Sleep(second / 2)
}
pb.Stop()
})
showcase("Spinner", 2, func() {
list := pseudoProgramList[7:]
spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
for i := 0; i < len(list); i++ {
spinner.UpdateText("Installing " + list[i])
if list[i] == "pseudo-minecraft" {
pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
} else {
pterm.Success.Println("Installing " + list[i])
}
time.Sleep(second)
}
spinner.Success()
})
showcase("Live Output", 2, func() {
pterm.Info.Println("You can use an Area to display changing output:")
pterm.Println()
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
})
showcase("Tables", 4, func() {
for i := 0; i < 3; i++ {
pterm.Println()
}
td := [][]string{
{"Library", "Description"},
{"PTerm", "Make beautiful CLIs"},
{"Testza", "Programmer friendly test framework"},
{"Cursor", "Move the cursor around the terminal"},
}
table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
pterm.DefaultCenter.Println(table)
pterm.DefaultCenter.Println(boxedTable)
})
showcase("TrueColor Support", 7, func() {
from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
strs := strings.Split(str, "")
var fadeInfo string // String which will be used to print info.
// For loop over the range of the string length.
for i := 0; i < len(str); i++ {
// Append faded letter to info string.
fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
}
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
text := "All printers are fully customizable!"
area := pterm.DefaultArea.WithCenter()
area.Update(pterm.DefaultBox.Sprintln(text))
time.Sleep(second)
area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).
WithBottomPadding(1).
WithLeftPadding(1).
WithRightPadding(1).
WithHorizontalString("═").
WithVerticalString("║").
WithBottomLeftCornerString("╗").
WithBottomRightCornerString("╔").
WithTopLeftCornerString("╝").
WithTopRightCornerString("╚").
Sprintln(text))
area.Stop()
})
showcase("Themes", 2, func() {
pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
time.Sleep(second / 2)
// Print every value of the default theme with its own style.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
for i := 0; i < v.NumField(); i++ {
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
field.Println(typeOfS.Field(i).Name)
}
time.Sleep(time.Millisecond * 250)
}
}
})
showcase("And much more!", 3, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
box := pterm.DefaultBox.
WithBottomPadding(1).
WithTopPadding(1).
WithLeftPadding(3).
WithRightPadding(3).
Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
pterm.DefaultCenter.Println(box)
})
}
func setup() {
flag.Parse()
if *speedup {
second = time.Millisecond * 200
}
}
func introScreen() {
ptermLogo, _ := pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
Srender()
pterm.DefaultCenter.Print(ptermLogo)
pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("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.WithShowTimer(false).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()
}
func clear() {
print("\033[H\033[2J")
}
func showcase(title string, seconds int, content func()) {
pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
pterm.Println()
time.Sleep(second / 2)
content()
time.Sleep(second * time.Duration(seconds))
print("\033[H\033[2J")
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(max-min+1) + min
}
```
golang-github-pterm-pterm-0.12.79/_examples/demo/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022523 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/demo/demo/README.md 0000664 0000000 0000000 00000025144 14650106263 0024010 0 ustar 00root root 0000000 0000000 # demo/demo
```go
package main
import (
"flag"
"math/rand"
"reflect"
"strconv"
"strings"
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
// go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second
var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
setup() // Setup the demo (flags etc.)
// Show intro
if !*skipIntro {
introScreen()
clear()
}
showcase("Structured Logging", 5, func() {
logger := pterm.DefaultLogger.
WithLevel(pterm.LogLevelTrace)
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
time.Sleep(time.Second * 3)
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
time.Sleep(time.Second * 3)
logger.Info("That was actually interesting", logger.Args("such", "wow"))
time.Sleep(time.Second * 3)
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
time.Sleep(time.Second * 3)
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
time.Sleep(time.Second * 3)
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
})
showcase("Progress bar", 2, func() {
pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
for i := 0; i < pb.Total; i++ {
pb.UpdateTitle("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])
}
pb.Increment()
time.Sleep(second / 2)
}
pb.Stop()
})
showcase("Spinner", 2, func() {
list := pseudoProgramList[7:]
spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
for i := 0; i < len(list); i++ {
spinner.UpdateText("Installing " + list[i])
if list[i] == "pseudo-minecraft" {
pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
} else {
pterm.Success.Println("Installing " + list[i])
}
time.Sleep(second)
}
spinner.Success()
})
showcase("Live Output", 2, func() {
pterm.Info.Println("You can use an Area to display changing output:")
pterm.Println()
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
})
showcase("Tables", 4, func() {
for i := 0; i < 3; i++ {
pterm.Println()
}
td := [][]string{
{"Library", "Description"},
{"PTerm", "Make beautiful CLIs"},
{"Testza", "Programmer friendly test framework"},
{"Cursor", "Move the cursor around the terminal"},
}
table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
pterm.DefaultCenter.Println(table)
pterm.DefaultCenter.Println(boxedTable)
})
showcase("TrueColor Support", 7, func() {
from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
strs := strings.Split(str, "")
var fadeInfo string // String which will be used to print info.
// For loop over the range of the string length.
for i := 0; i < len(str); i++ {
// Append faded letter to info string.
fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
}
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
text := "All printers are fully customizable!"
area := pterm.DefaultArea.WithCenter()
area.Update(pterm.DefaultBox.Sprintln(text))
time.Sleep(second)
area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).
WithBottomPadding(1).
WithLeftPadding(1).
WithRightPadding(1).
WithHorizontalString("═").
WithVerticalString("║").
WithBottomLeftCornerString("╗").
WithBottomRightCornerString("╔").
WithTopLeftCornerString("╝").
WithTopRightCornerString("╚").
Sprintln(text))
area.Stop()
})
showcase("Themes", 2, func() {
pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
time.Sleep(second / 2)
// Print every value of the default theme with its own style.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
for i := 0; i < v.NumField(); i++ {
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
field.Println(typeOfS.Field(i).Name)
}
time.Sleep(time.Millisecond * 250)
}
}
})
showcase("And much more!", 3, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
box := pterm.DefaultBox.
WithBottomPadding(1).
WithTopPadding(1).
WithLeftPadding(3).
WithRightPadding(3).
Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
pterm.DefaultCenter.Println(box)
})
}
func setup() {
flag.Parse()
if *speedup {
second = time.Millisecond * 200
}
}
func introScreen() {
ptermLogo, _ := pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
Srender()
pterm.DefaultCenter.Print(ptermLogo)
pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("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.WithShowTimer(false).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()
}
func clear() {
print("\033[H\033[2J")
}
func showcase(title string, seconds int, content func()) {
pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
pterm.Println()
time.Sleep(second / 2)
content()
time.Sleep(second * time.Duration(seconds))
print("\033[H\033[2J")
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(max-min+1) + min
}
```
golang-github-pterm-pterm-0.12.79/_examples/demo/demo/animation.svg 0000664 0000000 0000000 00001017613 14650106263 0025234 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/demo/demo/main.go 0000664 0000000 0000000 00000025057 14650106263 0024007 0 ustar 00root root 0000000 0000000 package main
import (
"flag"
"math/rand"
"reflect"
"strconv"
"strings"
"time"
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
// go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second
var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")
func main() {
setup() // Setup the demo (flags etc.)
// Show intro
if !*skipIntro {
introScreen()
clear()
}
showcase("Structured Logging", 5, func() {
logger := pterm.DefaultLogger.
WithLevel(pterm.LogLevelTrace)
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
time.Sleep(time.Second * 3)
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
time.Sleep(time.Second * 3)
logger.Info("That was actually interesting", logger.Args("such", "wow"))
time.Sleep(time.Second * 3)
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
time.Sleep(time.Second * 3)
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
time.Sleep(time.Second * 3)
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
})
showcase("Progress bar", 2, func() {
pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
for i := 0; i < pb.Total; i++ {
pb.UpdateTitle("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])
}
pb.Increment()
time.Sleep(second / 2)
}
pb.Stop()
})
showcase("Spinner", 2, func() {
list := pseudoProgramList[7:]
spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
for i := 0; i < len(list); i++ {
spinner.UpdateText("Installing " + list[i])
if list[i] == "pseudo-minecraft" {
pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
} else {
pterm.Success.Println("Installing " + list[i])
}
time.Sleep(second)
}
spinner.Success()
})
showcase("Live Output", 2, func() {
pterm.Info.Println("You can use an Area to display changing output:")
pterm.Println()
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
})
showcase("Tables", 4, func() {
for i := 0; i < 3; i++ {
pterm.Println()
}
td := [][]string{
{"Library", "Description"},
{"PTerm", "Make beautiful CLIs"},
{"Testza", "Programmer friendly test framework"},
{"Cursor", "Move the cursor around the terminal"},
}
table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
pterm.DefaultCenter.Println(table)
pterm.DefaultCenter.Println(boxedTable)
})
showcase("TrueColor Support", 7, func() {
from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
to := pterm.NewRGB(255, 0, 255) // This RGB value is used as the gradients first point.
str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
strs := strings.Split(str, "")
var fadeInfo string // String which will be used to print info.
// For loop over the range of the string length.
for i := 0; i < len(str); i++ {
// Append faded letter to info string.
fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
}
pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
})
showcase("Fully Customizable", 2, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
text := "All printers are fully customizable!"
area := pterm.DefaultArea.WithCenter()
area.Update(pterm.DefaultBox.Sprintln(text))
time.Sleep(second)
area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
time.Sleep(second / 3)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
time.Sleep(second / 5)
area.Update(pterm.DefaultBox.WithTopPadding(1).
WithBottomPadding(1).
WithLeftPadding(1).
WithRightPadding(1).
WithHorizontalString("═").
WithVerticalString("║").
WithBottomLeftCornerString("╗").
WithBottomRightCornerString("╔").
WithTopLeftCornerString("╝").
WithTopRightCornerString("╚").
Sprintln(text))
area.Stop()
})
showcase("Themes", 2, func() {
pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
time.Sleep(second / 2)
// Print every value of the default theme with its own style.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
for i := 0; i < v.NumField(); i++ {
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
field.Println(typeOfS.Field(i).Name)
}
time.Sleep(time.Millisecond * 250)
}
}
})
showcase("And much more!", 3, func() {
for i := 0; i < 4; i++ {
pterm.Println()
}
box := pterm.DefaultBox.
WithBottomPadding(1).
WithTopPadding(1).
WithLeftPadding(3).
WithRightPadding(3).
Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
pterm.DefaultCenter.Println(box)
})
}
func setup() {
flag.Parse()
if *speedup {
second = time.Millisecond * 200
}
}
func introScreen() {
ptermLogo, _ := pterm.DefaultBigText.WithLetters(
putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
Srender()
pterm.DefaultCenter.Print(ptermLogo)
pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("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.WithShowTimer(false).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()
}
func clear() {
print("\033[H\033[2J")
}
func showcase(title string, seconds int, content func()) {
pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
pterm.Println()
time.Sleep(second / 2)
content()
time.Sleep(second * time.Duration(seconds))
print("\033[H\033[2J")
}
func randomInt(min, max int) int {
rand.Seed(time.Now().UnixNano())
return rand.Intn(max-min+1) + min
}
golang-github-pterm-pterm-0.12.79/_examples/header/ 0000775 0000000 0000000 00000000000 14650106263 0022103 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/header/README.md 0000664 0000000 0000000 00000003015 14650106263 0023361 0 ustar 00root root 0000000 0000000 ### header/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
// This uses the default settings of PTerm to print a header.
pterm.DefaultHeader.Println("This is the default header!")
// Print a spacer line for better readability.
pterm.Println()
// Print a full-width header.
// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
```
### header/custom
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
newHeader := pterm.HeaderPrinter{
TextStyle: pterm.NewStyle(pterm.FgBlack),
BackgroundStyle: pterm.NewStyle(pterm.BgRed),
Margin: 20,
}
// Print the custom header using the new HeaderPrinter.
newHeader.Println("This is a custom header!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/header/custom/ 0000775 0000000 0000000 00000000000 14650106263 0023415 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/header/custom/README.md 0000664 0000000 0000000 00000001326 14650106263 0024676 0 ustar 00root root 0000000 0000000 # header/custom
```go
package main
import "github.com/pterm/pterm"
func main() {
// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
newHeader := pterm.HeaderPrinter{
TextStyle: pterm.NewStyle(pterm.FgBlack),
BackgroundStyle: pterm.NewStyle(pterm.BgRed),
Margin: 20,
}
// Print the custom header using the new HeaderPrinter.
newHeader.Println("This is a custom header!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/header/custom/animation.svg 0000664 0000000 0000000 00000006101 14650106263 0026113 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/header/custom/main.go 0000664 0000000 0000000 00000001235 14650106263 0024671 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")
// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
newHeader := pterm.HeaderPrinter{
TextStyle: pterm.NewStyle(pterm.FgBlack),
BackgroundStyle: pterm.NewStyle(pterm.BgRed),
Margin: 20,
}
// Print the custom header using the new HeaderPrinter.
newHeader.Println("This is a custom header!")
}
golang-github-pterm-pterm-0.12.79/_examples/header/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023027 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/header/demo/README.md 0000664 0000000 0000000 00000001053 14650106263 0024305 0 ustar 00root root 0000000 0000000 # header/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
// This uses the default settings of PTerm to print a header.
pterm.DefaultHeader.Println("This is the default header!")
// Print a spacer line for better readability.
pterm.Println()
// Print a full-width header.
// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
```
golang-github-pterm-pterm-0.12.79/_examples/header/demo/animation.svg 0000664 0000000 0000000 00000006227 14650106263 0025536 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/header/demo/main.go 0000664 0000000 0000000 00000000764 14650106263 0024311 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
// This uses the default settings of PTerm to print a header.
pterm.DefaultHeader.Println("This is the default header!")
// Print a spacer line for better readability.
pterm.Println()
// Print a full-width header.
// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/ 0000775 0000000 0000000 00000000000 14650106263 0022272 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/README.md 0000664 0000000 0000000 00000017370 14650106263 0023561 0 ustar 00root root 0000000 0000000 ### heatmap/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the labels for the X and Y axes of the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Create a heatmap with the defined data and axis labels, and enable RGB colors.
// Then render the heatmap.
pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
```
### heatmap/custom_colors
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, and render it
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithLegend(false).
WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
WithLegend().
Render()
}
```
### heatmap/custom_legend
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the header data for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
pterm.Println()
// Create the heatmap with the defined data and options
// Options are chained in a single line for simplicity
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithEnableRGB().
WithLegendLabel("custom").
WithLegendOnlyColoredCells().
Render() // Render the heatmap
}
```
### heatmap/custom_rgb
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
axisLabels := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Define the color range for the heatmap.
rgbRange := []pterm.RGB{
pterm.NewRGB(0, 0, 255),
pterm.NewRGB(255, 0, 0),
pterm.NewRGB(0, 255, 0),
pterm.NewRGB(255, 255, 0),
}
// Create and render the heatmap.
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(axisLabels).
WithEnableRGB().
WithRGBRange(rgbRange...).
Render()
}
```
### heatmap/no_grid
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis data for the heatmap.
axisData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, then render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
```
### heatmap/separated
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
pterm.Println()
// Create the heatmap with the specified data and options, and render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_colors/ 0000775 0000000 0000000 00000000000 14650106263 0025165 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_colors/README.md 0000664 0000000 0000000 00000002311 14650106263 0026441 0 ustar 00root root 0000000 0000000 # heatmap/custom_colors
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, and render it
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithLegend(false).
WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
WithLegend().
Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_colors/animation.svg 0000664 0000000 0000000 00000071454 14650106263 0027700 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_colors/main.go 0000664 0000000 0000000 00000002210 14650106263 0026433 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, and render it
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithLegend(false).
WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
WithLegend().
Render()
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_legend/ 0000775 0000000 0000000 00000000000 14650106263 0025122 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_legend/README.md 0000664 0000000 0000000 00000002360 14650106263 0026402 0 ustar 00root root 0000000 0000000 # heatmap/custom_legend
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the header data for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
pterm.Println()
// Create the heatmap with the defined data and options
// Options are chained in a single line for simplicity
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithEnableRGB().
WithLegendLabel("custom").
WithLegendOnlyColoredCells().
Render() // Render the heatmap
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_legend/animation.svg 0000664 0000000 0000000 00000063146 14650106263 0027634 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_legend/main.go 0000664 0000000 0000000 00000002257 14650106263 0026403 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the header data for the heatmap
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
pterm.Println()
// Create the heatmap with the defined data and options
// Options are chained in a single line for simplicity
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(headerData).
WithEnableRGB().
WithLegendLabel("custom").
WithLegendOnlyColoredCells().
Render() // Render the heatmap
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_rgb/ 0000775 0000000 0000000 00000000000 14650106263 0024436 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_rgb/README.md 0000664 0000000 0000000 00000002435 14650106263 0025721 0 ustar 00root root 0000000 0000000 # heatmap/custom_rgb
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
axisLabels := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Define the color range for the heatmap.
rgbRange := []pterm.RGB{
pterm.NewRGB(0, 0, 255),
pterm.NewRGB(255, 0, 0),
pterm.NewRGB(0, 255, 0),
pterm.NewRGB(255, 255, 0),
}
// Create and render the heatmap.
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(axisLabels).
WithEnableRGB().
WithRGBRange(rgbRange...).
Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_rgb/animation.svg 0000664 0000000 0000000 00000050565 14650106263 0027151 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/custom_rgb/main.go 0000664 0000000 0000000 00000002337 14650106263 0025716 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
axisLabels := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Define the color range for the heatmap.
rgbRange := []pterm.RGB{
pterm.NewRGB(0, 0, 255),
pterm.NewRGB(255, 0, 0),
pterm.NewRGB(0, 255, 0),
pterm.NewRGB(255, 255, 0),
}
// Create and render the heatmap.
pterm.DefaultHeatmap.
WithData(data).
WithBoxed(false).
WithAxisData(axisLabels).
WithEnableRGB().
WithRGBRange(rgbRange...).
Render()
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023216 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/demo/README.md 0000664 0000000 0000000 00000002012 14650106263 0024470 0 ustar 00root root 0000000 0000000 # heatmap/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the labels for the X and Y axes of the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Create a heatmap with the defined data and axis labels, and enable RGB colors.
// Then render the heatmap.
pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/demo/animation.svg 0000664 0000000 0000000 00000070121 14650106263 0025717 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/demo/main.go 0000664 0000000 0000000 00000001722 14650106263 0024473 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the labels for the X and Y axes of the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Create a heatmap with the defined data and axis labels, and enable RGB colors.
// Then render the heatmap.
pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/no_grid/ 0000775 0000000 0000000 00000000000 14650106263 0023713 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/no_grid/README.md 0000664 0000000 0000000 00000002164 14650106263 0025175 0 ustar 00root root 0000000 0000000 # heatmap/no_grid
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis data for the heatmap.
axisData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, then render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/no_grid/animation.svg 0000664 0000000 0000000 00000033370 14650106263 0026421 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/no_grid/main.go 0000664 0000000 0000000 00000002071 14650106263 0025166 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis data for the heatmap.
axisData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
pterm.Println()
// Create the heatmap with the defined data and options, then render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/heatmap/separated/ 0000775 0000000 0000000 00000000000 14650106263 0024242 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/separated/README.md 0000664 0000000 0000000 00000002140 14650106263 0025516 0 ustar 00root root 0000000 0000000 # heatmap/separated
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
pterm.Println()
// Create the heatmap with the specified data and options, and render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/heatmap/separated/animation.svg 0000664 0000000 0000000 00000044015 14650106263 0026746 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/heatmap/separated/main.go 0000664 0000000 0000000 00000002043 14650106263 0025514 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the heatmap.
data := [][]float32{
{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
}
// Define the axis labels for the heatmap.
headerData := pterm.HeatmapAxis{
XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
YAxis: []string{"1", "2", "3", "4", "5"},
}
// Print an informational message.
pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
pterm.Println()
// Create the heatmap with the specified data and options, and render it.
pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/ 0000775 0000000 0000000 00000000000 14650106263 0024705 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/README.md 0000664 0000000 0000000 00000001477 14650106263 0026175 0 ustar 00root root 0000000 0000000 ### interactive_confirm/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Show an interactive confirmation dialog and get the result.
result, _ := pterm.DefaultInteractiveConfirm.Show()
// Print a blank line for better readability.
pterm.Println()
// Print the user's answer in a formatted way.
pterm.Info.Printfln("You answered: %s", boolToText(result))
}
// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
if b {
return pterm.Green("Yes")
}
return pterm.Red("No")
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/demo/ 0000775 0000000 0000000 00000000000 14650106263 0025631 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/demo/README.md 0000664 0000000 0000000 00000001255 14650106263 0027113 0 ustar 00root root 0000000 0000000 # interactive_confirm/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Show an interactive confirmation dialog and get the result.
result, _ := pterm.DefaultInteractiveConfirm.Show()
// Print a blank line for better readability.
pterm.Println()
// Print the user's answer in a formatted way.
pterm.Info.Printfln("You answered: %s", boolToText(result))
}
// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
if b {
return pterm.Green("Yes")
}
return pterm.Red("No")
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/demo/animation.svg 0000664 0000000 0000000 00000010121 14650106263 0030324 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/demo/ci.go 0000664 0000000 0000000 00000000554 14650106263 0026557 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second * 2)
keyboard.SimulateKeyPress('y')
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_confirm/demo/main.go 0000664 0000000 0000000 00000001151 14650106263 0027102 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Show an interactive confirmation dialog and get the result.
result, _ := pterm.DefaultInteractiveConfirm.Show()
// Print a blank line for better readability.
pterm.Println()
// Print the user's answer in a formatted way.
pterm.Info.Printfln("You answered: %s", boolToText(result))
}
// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
if b {
return pterm.Green("Yes")
}
return pterm.Red("No")
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/ 0000775 0000000 0000000 00000000000 14650106263 0025074 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/README.md 0000664 0000000 0000000 00000001707 14650106263 0026360 0 ustar 00root root 0000000 0000000 ### interactive_continue/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive continue prompt with default settings
// This will pause the program execution until the user presses enter
// The message displayed is "Press 'Enter' to continue..."
prompt := pterm.DefaultInteractiveContinue
// Show the prompt and wait for user input
// The returned result is the user's input (should be empty as it's a continue prompt)
// The second return value is an error which is ignored here
result, _ := prompt.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's input with an info prefix
// As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/demo/ 0000775 0000000 0000000 00000000000 14650106263 0026020 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/demo/README.md 0000664 0000000 0000000 00000001464 14650106263 0027304 0 ustar 00root root 0000000 0000000 # interactive_continue/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive continue prompt with default settings
// This will pause the program execution until the user presses enter
// The message displayed is "Press 'Enter' to continue..."
prompt := pterm.DefaultInteractiveContinue
// Show the prompt and wait for user input
// The returned result is the user's input (should be empty as it's a continue prompt)
// The second return value is an error which is ignored here
result, _ := prompt.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's input with an info prefix
// As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/demo/animation.svg 0000664 0000000 0000000 00000010041 14650106263 0030514 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/demo/ci.go 0000664 0000000 0000000 00000000554 14650106263 0026746 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second * 2)
keyboard.SimulateKeyPress('y')
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_continue/demo/main.go 0000664 0000000 0000000 00000001357 14650106263 0027301 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive continue prompt with default settings
// This will pause the program execution until the user presses enter
// The message displayed is "Press 'Enter' to continue..."
prompt := pterm.DefaultInteractiveContinue
// Show the prompt and wait for user input
// The returned result is the user's input (should be empty as it's a continue prompt)
// The second return value is an error which is ignored here
result, _ := prompt.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's input with an info prefix
// As this is a continue prompt, the input should be empty
pterm.Info.Printfln("You answered: %s", result)
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/ 0000775 0000000 0000000 00000000000 14650106263 0025602 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/README.md 0000664 0000000 0000000 00000006172 14650106263 0027067 0 ustar 00root root 0000000 0000000 ### interactive_multiselect/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options.
var options []string
// Populate the options slice with 100 options.
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Add 5 more options to the slice, indicating the availability of fuzzy searching.
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
// The Show() method displays the options and waits for user input.
selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
// Print the selected options, highlighted in green.
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-checkmarks
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and define the checkmark symbols
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
### interactive_multiselect/custom-keys
SHOW SOURCE
```go
package main
import (
"atomicgo.dev/keyboard/keys"
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and set the keys for confirming and selecting options
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithKeyConfirm(keys.Enter).
WithKeySelect(keys.Space)
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-checkmarks/ 0000775 0000000 0000000 00000000000 14650106263 0031225 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-checkmarks/README.md 0000664 0000000 0000000 00000001562 14650106263 0032510 0 ustar 00root root 0000000 0000000 # interactive_multiselect/custom-checkmarks
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and define the checkmark symbols
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-checkmarks/animation.svg 0000664 0000000 0000000 00000105712 14650106263 0033733 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-checkmarks/ci.go 0000664 0000000 0000000 00000001534 14650106263 0032152 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
for i := 0; i < 10; i++ {
keyboard.SimulateKeyPress(keys.Down)
if i%2 == 0 {
time.Sleep(time.Millisecond * 100)
keyboard.SimulateKeyPress(keys.Enter)
}
time.Sleep(time.Millisecond * 500)
}
time.Sleep(time.Second)
for _, s := range "fuzzy" {
keyboard.SimulateKeyPress(s)
time.Sleep(time.Millisecond * 150)
}
time.Sleep(time.Second)
keyboard.SimulateKeyPress(keys.Enter)
time.Sleep(time.Millisecond * 350)
keyboard.SimulateKeyPress(keys.Tab)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-checkmarks/main.go 0000664 0000000 0000000 00000001435 14650106263 0032503 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and define the checkmark symbols
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-keys/ 0000775 0000000 0000000 00000000000 14650106263 0030065 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-keys/README.md 0000664 0000000 0000000 00000001601 14650106263 0031342 0 ustar 00root root 0000000 0000000 # interactive_multiselect/custom-keys
```go
package main
import (
"atomicgo.dev/keyboard/keys"
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and set the keys for confirming and selecting options
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithKeyConfirm(keys.Enter).
WithKeySelect(keys.Space)
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-keys/animation.svg 0000664 0000000 0000000 00000032052 14650106263 0032567 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-keys/ci.go 0000664 0000000 0000000 00000001312 14650106263 0031004 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
keyboard.SimulateKeyPress(keys.Down)
time.Sleep(time.Millisecond * 100)
keyboard.SimulateKeyPress(keys.Space)
time.Sleep(time.Millisecond * 300)
keyboard.SimulateKeyPress(keys.Down)
time.Sleep(time.Millisecond * 100)
keyboard.SimulateKeyPress(keys.Space)
time.Sleep(time.Millisecond * 300)
keyboard.SimulateKeyPress(keys.Enter)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/custom-keys/main.go 0000664 0000000 0000000 00000001462 14650106263 0031343 0 ustar 00root root 0000000 0000000 package main
import (
"atomicgo.dev/keyboard/keys"
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Populate the options slice with 5 options
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Create a new interactive multiselect printer with the options
// Disable the filter and set the keys for confirming and selecting options
printer := pterm.DefaultInteractiveMultiselect.
WithOptions(options).
WithFilter(false).
WithKeyConfirm(keys.Enter).
WithKeySelect(keys.Space)
// Show the interactive multiselect and get the selected options
selectedOptions, _ := printer.Show()
// Print the selected options
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/demo/ 0000775 0000000 0000000 00000000000 14650106263 0026526 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/demo/README.md 0000664 0000000 0000000 00000001661 14650106263 0030011 0 ustar 00root root 0000000 0000000 # interactive_multiselect/demo
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options.
var options []string
// Populate the options slice with 100 options.
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Add 5 more options to the slice, indicating the availability of fuzzy searching.
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
// The Show() method displays the options and waits for user input.
selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
// Print the selected options, highlighted in green.
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/demo/animation.svg 0000664 0000000 0000000 00000165145 14650106263 0031242 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/demo/ci.go 0000664 0000000 0000000 00000001716 14650106263 0027455 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
for i := 0; i < 10; i++ {
keyboard.SimulateKeyPress(keys.Down)
if i%2 == 0 {
time.Sleep(time.Millisecond * 100)
keyboard.SimulateKeyPress(keys.Enter)
}
time.Sleep(time.Millisecond * 500)
}
time.Sleep(time.Second)
for _, s := range "fuzzy" {
keyboard.SimulateKeyPress(s)
time.Sleep(time.Millisecond * 150)
}
time.Sleep(time.Second)
for i := 0; i < 2; i++ {
keyboard.SimulateKeyPress(keys.Down)
time.Sleep(time.Millisecond * 300)
}
keyboard.SimulateKeyPress(keys.Enter)
time.Sleep(time.Millisecond * 350)
keyboard.SimulateKeyPress(keys.Tab)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_multiselect/demo/main.go 0000664 0000000 0000000 00000001551 14650106263 0030003 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options.
var options []string
// Populate the options slice with 100 options.
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Add 5 more options to the slice, indicating the availability of fuzzy searching.
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
// The Show() method displays the options and waits for user input.
selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()
// Print the selected options, highlighted in green.
pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_select/ 0000775 0000000 0000000 00000000000 14650106263 0024527 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_select/README.md 0000664 0000000 0000000 00000002141 14650106263 0026004 0 ustar 00root root 0000000 0000000 ### interactive_select/demo
SHOW SOURCE
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Generate 100 options and add them to the options slice
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Generate 5 additional options with a specific message and add them to the options slice
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive select feature to present the options to the user and capture their selection
// The Show() method displays the options and waits for the user's input
selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
// Display the selected option to the user with a green color for emphasis
pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_select/demo/ 0000775 0000000 0000000 00000000000 14650106263 0025453 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_select/demo/README.md 0000664 0000000 0000000 00000001720 14650106263 0026732 0 ustar 00root root 0000000 0000000 # interactive_select/demo
```go
package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Generate 100 options and add them to the options slice
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Generate 5 additional options with a specific message and add them to the options slice
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive select feature to present the options to the user and capture their selection
// The Show() method displays the options and waits for the user's input
selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
// Display the selected option to the user with a green color for emphasis
pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_select/demo/animation.svg 0000664 0000000 0000000 00000071667 14650106263 0030174 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_select/demo/ci.go 0000664 0000000 0000000 00000001426 14650106263 0026400 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
for i := 0; i < 10; i++ {
keyboard.SimulateKeyPress(keys.Down)
time.Sleep(time.Millisecond * 250)
}
time.Sleep(time.Second)
for _, s := range "fuzzy" {
keyboard.SimulateKeyPress(s)
time.Sleep(time.Millisecond * 150)
}
time.Sleep(time.Second)
for i := 0; i < 2; i++ {
keyboard.SimulateKeyPress(keys.Down)
time.Sleep(time.Millisecond * 300)
}
keyboard.SimulateKeyPress(keys.Enter)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_select/demo/main.go 0000664 0000000 0000000 00000001615 14650106263 0026731 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"github.com/pterm/pterm"
)
func main() {
// Initialize an empty slice to hold the options
var options []string
// Generate 100 options and add them to the options slice
for i := 0; i < 100; i++ {
options = append(options, fmt.Sprintf("Option %d", i))
}
// Generate 5 additional options with a specific message and add them to the options slice
for i := 0; i < 5; i++ {
options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
}
// Use PTerm's interactive select feature to present the options to the user and capture their selection
// The Show() method displays the options and waits for the user's input
selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()
// Display the selected option to the user with a green color for emphasis
pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/ 0000775 0000000 0000000 00000000000 14650106263 0025314 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/README.md 0000664 0000000 0000000 00000005517 14650106263 0026603 0 ustar 00root root 0000000 0000000 ### interactive_textinput/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/default-value
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/multi-line
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create a default interactive text input with multi-line enabled.
// This allows the user to input multiple lines of text.
textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
// Show the text input to the user and store the result.
// The second return value (an error) is ignored with '_'.
result, _ := textInput.Show()
// Print a blank line for better readability in the output.
pterm.Println()
// Print the user's input prefixed with an informational message.
// The '%s' placeholder is replaced with the user's input.
pterm.Info.Printfln("You answered: %s", result)
}
```
### interactive_textinput/password
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create an interactive text input with a mask for password input
passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
// Show the password input prompt and store the result
result, _ := passwordInput.Show("Enter your password")
// Get the default logger from PTerm
logger := pterm.DefaultLogger
// Log the received password (masked)
// Note: In a real-world application, you should never log passwords
logger.Info("Password received", logger.Args("password", result))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/default-value/ 0000775 0000000 0000000 00000000000 14650106263 0030052 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/default-value/README.md 0000664 0000000 0000000 00000000740 14650106263 0031332 0 ustar 00root root 0000000 0000000 # interactive_textinput/default-value
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/default-value/animation.svg 0000664 0000000 0000000 00000035450 14650106263 0032561 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/default-value/ci.go 0000664 0000000 0000000 00000001465 14650106263 0031002 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Millisecond * 1500)
input := "Hello; World!"
for _, r := range []rune(input) {
keyboard.SimulateKeyPress(r)
time.Sleep(time.Millisecond * 250)
}
for i := 0; i < 7; i++ {
keyboard.SimulateKeyPress(keys.Left)
time.Sleep(time.Millisecond * 150)
}
keyboard.SimulateKeyPress(keys.Backspace)
time.Sleep(time.Millisecond * 500)
keyboard.SimulateKeyPress(',')
time.Sleep(time.Millisecond * 500)
keyboard.SimulateKeyPress(keys.Enter)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/default-value/main.go 0000664 0000000 0000000 00000000621 14650106263 0031324 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/demo/ 0000775 0000000 0000000 00000000000 14650106263 0026240 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/demo/README.md 0000664 0000000 0000000 00000000660 14650106263 0027521 0 ustar 00root root 0000000 0000000 # interactive_textinput/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/demo/animation.svg 0000664 0000000 0000000 00000040043 14650106263 0030741 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/demo/ci.go 0000664 0000000 0000000 00000001451 14650106263 0027163 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
input := "Hello; World!"
for _, r := range []rune(input) {
keyboard.SimulateKeyPress(r)
time.Sleep(time.Millisecond * 250)
}
for i := 0; i < 7; i++ {
keyboard.SimulateKeyPress(keys.Left)
time.Sleep(time.Millisecond * 150)
}
keyboard.SimulateKeyPress(keys.Backspace)
time.Sleep(time.Millisecond * 500)
keyboard.SimulateKeyPress(',')
time.Sleep(time.Millisecond * 500)
keyboard.SimulateKeyPress(keys.Enter)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/demo/main.go 0000664 0000000 0000000 00000000552 14650106263 0027515 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create an interactive text input with single line input mode and show it
result, _ := pterm.DefaultInteractiveTextInput.Show()
// Print a blank line for better readability
pterm.Println()
// Print the user's answer with an info prefix
pterm.Info.Printfln("You answered: %s", result)
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/multi-line/ 0000775 0000000 0000000 00000000000 14650106263 0027373 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/multi-line/README.md 0000664 0000000 0000000 00000001345 14650106263 0030655 0 ustar 00root root 0000000 0000000 # interactive_textinput/multi-line
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create a default interactive text input with multi-line enabled.
// This allows the user to input multiple lines of text.
textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
// Show the text input to the user and store the result.
// The second return value (an error) is ignored with '_'.
result, _ := textInput.Show()
// Print a blank line for better readability in the output.
pterm.Println()
// Print the user's input prefixed with an informational message.
// The '%s' placeholder is replaced with the user's input.
pterm.Info.Printfln("You answered: %s", result)
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/multi-line/animation.svg 0000664 0000000 0000000 00000114724 14650106263 0032104 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/multi-line/ci.go 0000664 0000000 0000000 00000002132 14650106263 0030313 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
input := "1111111\n2222222"
for _, r := range input {
if r == '\n' {
keyboard.SimulateKeyPress(keys.Enter)
} else {
keyboard.SimulateKeyPress(r)
}
time.Sleep(time.Millisecond * 250)
}
for i := 0; i < 7; i++ {
keyboard.SimulateKeyPress(keys.Left)
time.Sleep(time.Millisecond * 150)
}
keyboard.SimulateKeyPress(keys.Backspace)
time.Sleep(time.Millisecond * 500)
keyboard.SimulateKeyPress(keys.Enter)
time.Sleep(time.Millisecond * 500)
input = "33333333\n4\n5555555"
for _, r := range input {
if r == '\n' {
keyboard.SimulateKeyPress(keys.Enter)
} else {
keyboard.SimulateKeyPress(r)
}
time.Sleep(time.Millisecond * 250)
}
keyboard.SimulateKeyPress(keys.Tab)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/multi-line/main.go 0000664 0000000 0000000 00000001231 14650106263 0030643 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Create a default interactive text input with multi-line enabled.
// This allows the user to input multiple lines of text.
textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()
// Show the text input to the user and store the result.
// The second return value (an error) is ignored with '_'.
result, _ := textInput.Show()
// Print a blank line for better readability in the output.
pterm.Println()
// Print the user's input prefixed with an informational message.
// The '%s' placeholder is replaced with the user's input.
pterm.Info.Printfln("You answered: %s", result)
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/password/ 0000775 0000000 0000000 00000000000 14650106263 0027156 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/password/README.md 0000664 0000000 0000000 00000001167 14650106263 0030442 0 ustar 00root root 0000000 0000000 # interactive_textinput/password
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create an interactive text input with a mask for password input
passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
// Show the password input prompt and store the result
result, _ := passwordInput.Show("Enter your password")
// Get the default logger from PTerm
logger := pterm.DefaultLogger
// Log the received password (masked)
// Note: In a real-world application, you should never log passwords
logger.Info("Password received", logger.Args("password", result))
}
```
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/password/animation.svg 0000664 0000000 0000000 00000032341 14650106263 0031661 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/password/ci.go 0000664 0000000 0000000 00000001146 14650106263 0030102 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"time"
"atomicgo.dev/keyboard"
"atomicgo.dev/keyboard/keys"
)
// ------ Automation for CI ------
// You can ignore this function, it is used to automatically run the demo and generate the example animation in our CI system.
func init() {
if os.Getenv("CI") == "true" {
go func() {
time.Sleep(time.Second)
input := "Hello, World!"
for _, r := range input {
if r == '\n' {
keyboard.SimulateKeyPress(keys.Enter)
} else {
keyboard.SimulateKeyPress(r)
}
time.Sleep(time.Millisecond * 250)
}
keyboard.SimulateKeyPress(keys.Enter)
}()
}
}
golang-github-pterm-pterm-0.12.79/_examples/interactive_textinput/password/main.go 0000664 0000000 0000000 00000001055 14650106263 0030432 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create an interactive text input with a mask for password input
passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")
// Show the password input prompt and store the result
result, _ := passwordInput.Show("Enter your password")
// Get the default logger from PTerm
logger := pterm.DefaultLogger
// Log the received password (masked)
// Note: In a real-world application, you should never log passwords
logger.Info("Password received", logger.Args("password", result))
}
golang-github-pterm-pterm-0.12.79/_examples/logger/ 0000775 0000000 0000000 00000000000 14650106263 0022132 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/README.md 0000664 0000000 0000000 00000017517 14650106263 0023424 0 ustar 00root root 0000000 0000000 ### logger/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with trace level
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace level message
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Pause for 3 seconds
sleep()
// Define a map with interesting stuff
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Pause for 3 seconds
sleep()
// Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Pause for 3 seconds
sleep()
// Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Pause for 3 seconds
sleep()
// Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Pause for 3 seconds
sleep()
// Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 3 seconds
sleep()
// Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
```
### logger/custom-key-styles
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Define a new style for the "priority" key.
priorityStyle := map[string]pterm.Style{
"priority": *pterm.NewStyle(pterm.FgRed),
}
// Overwrite all key styles with the new map.
logger = logger.WithKeyStyles(priorityStyle)
// Log an info message. The "priority" key will be displayed in red.
logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
// Define a new style for the "foo" key.
fooStyle := *pterm.NewStyle(pterm.FgBlue)
// Append the new style to the existing ones.
logger.AppendKeyStyle("foo", fooStyle)
// Log another info message. The "foo" key will be displayed in blue.
logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}
```
### logger/default
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Log an info message with additional arguments.
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments.
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments.
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 2 seconds.
time.Sleep(time.Second * 2)
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/json
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and JSON formatter
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
// Log a Trace level message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a Debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
### logger/with-caller
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and caller information
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
// Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/custom-key-styles/ 0000775 0000000 0000000 00000000000 14650106263 0025553 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/custom-key-styles/README.md 0000664 0000000 0000000 00000001730 14650106263 0027033 0 ustar 00root root 0000000 0000000 # logger/custom-key-styles
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Define a new style for the "priority" key.
priorityStyle := map[string]pterm.Style{
"priority": *pterm.NewStyle(pterm.FgRed),
}
// Overwrite all key styles with the new map.
logger = logger.WithKeyStyles(priorityStyle)
// Log an info message. The "priority" key will be displayed in red.
logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
// Define a new style for the "foo" key.
fooStyle := *pterm.NewStyle(pterm.FgBlue)
// Append the new style to the existing ones.
logger.AppendKeyStyle("foo", fooStyle)
// Log another info message. The "foo" key will be displayed in blue.
logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/custom-key-styles/animation.svg 0000664 0000000 0000000 00000007712 14650106263 0030262 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/custom-key-styles/main.go 0000664 0000000 0000000 00000001624 14650106263 0027031 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Define a new style for the "priority" key.
priorityStyle := map[string]pterm.Style{
"priority": *pterm.NewStyle(pterm.FgRed),
}
// Overwrite all key styles with the new map.
logger = logger.WithKeyStyles(priorityStyle)
// Log an info message. The "priority" key will be displayed in red.
logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))
// Define a new style for the "foo" key.
fooStyle := *pterm.NewStyle(pterm.FgBlue)
// Append the new style to the existing ones.
logger.AppendKeyStyle("foo", fooStyle)
// Log another info message. The "foo" key will be displayed in blue.
logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}
golang-github-pterm-pterm-0.12.79/_examples/logger/default/ 0000775 0000000 0000000 00000000000 14650106263 0023556 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/default/README.md 0000664 0000000 0000000 00000003155 14650106263 0025041 0 ustar 00root root 0000000 0000000 # logger/default
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Log an info message with additional arguments.
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments.
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments.
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 2 seconds.
time.Sleep(time.Second * 2)
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/default/animation.svg 0000664 0000000 0000000 00000026577 14650106263 0026277 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/default/main.go 0000664 0000000 0000000 00000003063 14650106263 0025033 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with a level of Trace or higher.
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace message with additional arguments.
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff.
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map.
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Log an info message with additional arguments.
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments.
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments.
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 2 seconds.
time.Sleep(time.Second * 2)
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
golang-github-pterm-pterm-0.12.79/_examples/logger/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023056 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/demo/README.md 0000664 0000000 0000000 00000003303 14650106263 0024334 0 ustar 00root root 0000000 0000000 # logger/demo
```go
package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with trace level
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace level message
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Pause for 3 seconds
sleep()
// Define a map with interesting stuff
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Pause for 3 seconds
sleep()
// Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Pause for 3 seconds
sleep()
// Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Pause for 3 seconds
sleep()
// Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Pause for 3 seconds
sleep()
// Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 3 seconds
sleep()
// Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/demo/animation.svg 0000664 0000000 0000000 00000030356 14650106263 0025565 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/demo/main.go 0000664 0000000 0000000 00000003214 14650106263 0024331 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"time"
)
func main() {
// Create a logger with trace level
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)
// Log a trace level message
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Pause for 3 seconds
sleep()
// Define a map with interesting stuff
interstingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
// Pause for 3 seconds
sleep()
// Log an info level message
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Pause for 3 seconds
sleep()
// Log a warning level message
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Pause for 3 seconds
sleep()
// Log an error level message
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Pause for 3 seconds
sleep()
// Log an info level message with a long text that will be automatically wrapped
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Pause for 3 seconds
sleep()
// Log a fatal level message
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
// Function to pause the execution for 3 seconds
func sleep() {
time.Sleep(time.Second * 3)
}
golang-github-pterm-pterm-0.12.79/_examples/logger/json/ 0000775 0000000 0000000 00000000000 14650106263 0023103 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/json/README.md 0000664 0000000 0000000 00000002532 14650106263 0024364 0 ustar 00root root 0000000 0000000 # logger/json
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and JSON formatter
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
// Log a Trace level message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a Debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/json/animation.svg 0000664 0000000 0000000 00000022461 14650106263 0025610 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/json/main.go 0000664 0000000 0000000 00000002443 14650106263 0024361 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and JSON formatter
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)
// Log a Trace level message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a Debug level message with arguments from the map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log Info, Warn, Error, and Fatal level messages with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
golang-github-pterm-pterm-0.12.79/_examples/logger/with-caller/ 0000775 0000000 0000000 00000000000 14650106263 0024345 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/with-caller/README.md 0000664 0000000 0000000 00000003075 14650106263 0025631 0 ustar 00root root 0000000 0000000 # logger/with-caller
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and caller information
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
// Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
```
golang-github-pterm-pterm-0.12.79/_examples/logger/with-caller/animation.svg 0000664 0000000 0000000 00000043203 14650106263 0027047 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/logger/with-caller/main.go 0000664 0000000 0000000 00000002777 14650106263 0025635 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a logger with Trace level and caller information
logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()
// Log a trace message with additional arguments
logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))
// Create a map of interesting stuff
interestingStuff := map[string]any{
"when were crayons invented": "1903",
"what is the meaning of life": 42,
"is this interesting": true,
}
// Log a debug message with arguments from a map
logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))
// Log an info message with additional arguments
logger.Info("That was actually interesting", logger.Args("such", "wow"))
// Log a warning message with additional arguments
logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
// Log an error message with additional arguments
logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
// Log an info message with additional arguments. PTerm will automatically wrap long logs.
logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
// Log a fatal message with additional arguments. This will terminate the process.
logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}
golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/ 0000775 0000000 0000000 00000000000 14650106263 0025307 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/README.md 0000664 0000000 0000000 00000004106 14650106263 0026567 0 ustar 00root root 0000000 0000000 ### multiple-live-printers/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer for managing multiple printers
multi := pterm.DefaultMultiPrinter
// Create two spinners with their own writers
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create five progress bars with their own writers and a total of 100
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Increment progress bars and spinners based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment progress bar 1 every iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 to progress bar 2 every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment progress bar 3 every 5th iteration
}
if i%10 == 0 {
pb4.Increment() // Increment progress bar 4 every 10th iteration
}
if i%3 == 0 {
pb5.Increment() // Increment progress bar 5 every 3rd iteration
}
if i%50 == 0 {
spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
}
if i%60 == 0 {
spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
}
time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
}
// Stop the multi printer
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/demo/ 0000775 0000000 0000000 00000000000 14650106263 0026233 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/demo/README.md 0000664 0000000 0000000 00000003661 14650106263 0027520 0 ustar 00root root 0000000 0000000 # multiple-live-printers/demo
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer for managing multiple printers
multi := pterm.DefaultMultiPrinter
// Create two spinners with their own writers
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create five progress bars with their own writers and a total of 100
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Increment progress bars and spinners based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment progress bar 1 every iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 to progress bar 2 every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment progress bar 3 every 5th iteration
}
if i%10 == 0 {
pb4.Increment() // Increment progress bar 4 every 10th iteration
}
if i%3 == 0 {
pb5.Increment() // Increment progress bar 5 every 3rd iteration
}
if i%50 == 0 {
spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
}
if i%60 == 0 {
spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
}
time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
}
// Stop the multi printer
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/demo/animation.svg 0000664 0000000 0000000 00000407777 14650106263 0030761 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/multiple-live-printers/demo/main.go 0000664 0000000 0000000 00000003552 14650106263 0027513 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer for managing multiple printers
multi := pterm.DefaultMultiPrinter
// Create two spinners with their own writers
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create five progress bars with their own writers and a total of 100
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Increment progress bars and spinners based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment progress bar 1 every iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 to progress bar 2 every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment progress bar 3 every 5th iteration
}
if i%10 == 0 {
pb4.Increment() // Increment progress bar 4 every 10th iteration
}
if i%3 == 0 {
pb5.Increment() // Increment progress bar 5 every 3rd iteration
}
if i%50 == 0 {
spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
}
if i%60 == 0 {
spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
}
time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
}
// Stop the multi printer
multi.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/panel/ 0000775 0000000 0000000 00000000000 14650106263 0021752 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/panel/README.md 0000664 0000000 0000000 00000001273 14650106263 0023234 0 ustar 00root root 0000000 0000000 ### panel/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define panels in a 2D grid system
panels := pterm.Panels{
{
{Data: "This is the first panel"},
{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
{Data: "This\npanel\ncontains\nmultiple\nlines"},
},
{
{Data: pterm.Red("This is another\npanel line")},
{Data: "This is the second panel\nwith a new line"},
},
}
// Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/panel/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022676 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/panel/demo/README.md 0000664 0000000 0000000 00000001067 14650106263 0024161 0 ustar 00root root 0000000 0000000 # panel/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define panels in a 2D grid system
panels := pterm.Panels{
{
{Data: "This is the first panel"},
{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
{Data: "This\npanel\ncontains\nmultiple\nlines"},
},
{
{Data: pterm.Red("This is another\npanel line")},
{Data: "This is the second panel\nwith a new line"},
},
}
// Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/panel/demo/animation.svg 0000664 0000000 0000000 00000010264 14650106263 0025401 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/panel/demo/main.go 0000664 0000000 0000000 00000001001 14650106263 0024141 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define panels in a 2D grid system
panels := pterm.Panels{
{
{Data: "This is the first panel"},
{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
{Data: "This\npanel\ncontains\nmultiple\nlines"},
},
{
{Data: pterm.Red("This is another\npanel line")},
{Data: "This is the second panel\nwith a new line"},
},
}
// Render the panels with a padding of 5
_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/paragraph/ 0000775 0000000 0000000 00000000000 14650106263 0022620 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/paragraph/README.md 0000664 0000000 0000000 00000005200 14650106263 0024074 0 ustar 00root root 0000000 0000000 ### paragraph/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Using the default paragraph printer to print a long text.
// The text is split at the spaces, which is useful for continuous text of all kinds.
// The line width can be manually adjusted if needed.
pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
// Printing a line space for separation.
pterm.Println()
// Printing a long text without using the paragraph printer.
// The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
```
### paragraph/customized
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a long text to be printed as a paragraph.
longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text as a paragraph with a custom maximal width of 60 characters.
pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
// Print a line space to separate the paragraph from the following text.
pterm.Println()
// Define another long text to be printed without a paragraph printer.
longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text without using a paragraph printer.
pterm.Println(longTextWithoutParagraph)
}
```
golang-github-pterm-pterm-0.12.79/_examples/paragraph/customized/ 0000775 0000000 0000000 00000000000 14650106263 0025006 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/paragraph/customized/README.md 0000664 0000000 0000000 00000002310 14650106263 0026261 0 ustar 00root root 0000000 0000000 # paragraph/customized
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a long text to be printed as a paragraph.
longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text as a paragraph with a custom maximal width of 60 characters.
pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
// Print a line space to separate the paragraph from the following text.
pterm.Println()
// Define another long text to be printed without a paragraph printer.
longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text without using a paragraph printer.
pterm.Println(longTextWithoutParagraph)
}
```
golang-github-pterm-pterm-0.12.79/_examples/paragraph/customized/animation.svg 0000664 0000000 0000000 00000017302 14650106263 0027511 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/paragraph/customized/main.go 0000664 0000000 0000000 00000002210 14650106263 0026254 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define a long text to be printed as a paragraph.
longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text as a paragraph with a custom maximal width of 60 characters.
pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)
// Print a line space to separate the paragraph from the following text.
pterm.Println()
// Define another long text to be printed without a paragraph printer.
longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"
// Print the long text without using a paragraph printer.
pterm.Println(longTextWithoutParagraph)
}
golang-github-pterm-pterm-0.12.79/_examples/paragraph/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023544 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/paragraph/demo/README.md 0000664 0000000 0000000 00000002242 14650106263 0025023 0 ustar 00root root 0000000 0000000 # paragraph/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Using the default paragraph printer to print a long text.
// The text is split at the spaces, which is useful for continuous text of all kinds.
// The line width can be manually adjusted if needed.
pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
// Printing a line space for separation.
pterm.Println()
// Printing a long text without using the paragraph printer.
// The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
```
golang-github-pterm-pterm-0.12.79/_examples/paragraph/demo/animation.svg 0000664 0000000 0000000 00000017052 14650106263 0026251 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/paragraph/demo/main.go 0000664 0000000 0000000 00000002150 14650106263 0025015 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Using the default paragraph printer to print a long text.
// The text is split at the spaces, which is useful for continuous text of all kinds.
// The line width can be manually adjusted if needed.
pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
// Printing a line space for separation.
pterm.Println()
// Printing a long text without using the paragraph printer.
// The default Println() function is used here, which does not provide intelligent splitting.
pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}
golang-github-pterm-pterm-0.12.79/_examples/prefix/ 0000775 0000000 0000000 00000000000 14650106263 0022150 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/prefix/README.md 0000664 0000000 0000000 00000002356 14650106263 0023435 0 ustar 00root root 0000000 0000000 ### prefix/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Enable debug messages in PTerm.
pterm.EnableDebugMessages()
// Print a debug message with PTerm.
pterm.Debug.Println("Hello, World!")
// Print an informational message with PTerm.
pterm.Info.Println("Hello, World!")
// Print a success message with PTerm.
pterm.Success.Println("Hello, World!")
// Print a warning message with PTerm.
pterm.Warning.Println("Hello, World!")
// Print an error message with PTerm. This will also display the filename and line number in the terminal.
pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
// Print an informational message with PTerm, with line number.
// This demonstrates that other PrefixPrinters can also display line numbers.
pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
// Temporarily set Fatal to false, so that the CI won't crash.
// This will print a fatal message with PTerm, but won't terminate the program.
pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/prefix/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023074 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/prefix/demo/README.md 0000664 0000000 0000000 00000002151 14650106263 0024352 0 ustar 00root root 0000000 0000000 # prefix/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Enable debug messages in PTerm.
pterm.EnableDebugMessages()
// Print a debug message with PTerm.
pterm.Debug.Println("Hello, World!")
// Print an informational message with PTerm.
pterm.Info.Println("Hello, World!")
// Print a success message with PTerm.
pterm.Success.Println("Hello, World!")
// Print a warning message with PTerm.
pterm.Warning.Println("Hello, World!")
// Print an error message with PTerm. This will also display the filename and line number in the terminal.
pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
// Print an informational message with PTerm, with line number.
// This demonstrates that other PrefixPrinters can also display line numbers.
pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
// Temporarily set Fatal to false, so that the CI won't crash.
// This will print a fatal message with PTerm, but won't terminate the program.
pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/prefix/demo/animation.svg 0000664 0000000 0000000 00000012143 14650106263 0025575 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/prefix/demo/main.go 0000664 0000000 0000000 00000002062 14650106263 0024347 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Enable debug messages in PTerm.
pterm.EnableDebugMessages()
// Print a debug message with PTerm.
pterm.Debug.Println("Hello, World!")
// Print an informational message with PTerm.
pterm.Info.Println("Hello, World!")
// Print a success message with PTerm.
pterm.Success.Println("Hello, World!")
// Print a warning message with PTerm.
pterm.Warning.Println("Hello, World!")
// Print an error message with PTerm. This will also display the filename and line number in the terminal.
pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")
// Print an informational message with PTerm, with line number.
// This demonstrates that other PrefixPrinters can also display line numbers.
pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")
// Temporarily set Fatal to false, so that the CI won't crash.
// This will print a fatal message with PTerm, but won't terminate the program.
pterm.Fatal.WithFatal(false).Println("Hello, World!")
}
golang-github-pterm-pterm-0.12.79/_examples/progressbar/ 0000775 0000000 0000000 00000000000 14650106263 0023204 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/progressbar/README.md 0000664 0000000 0000000 00000006324 14650106263 0024470 0 ustar 00root root 0000000 0000000 ### progressbar/demo
SHOW SOURCE
```go
package main
import (
"strings"
"time"
"github.com/pterm/pterm"
)
// Slice of strings representing names of pseudo applications to be downloaded.
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", " ")
func main() {
// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
// Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
// Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
// Simulate a slow download for the 7th item.
if i == 6 {
time.Sleep(time.Second * 3)
}
// Update the title of the progressbar with the current item being downloaded.
p.UpdateTitle("Downloading " + fakeInstallList[i])
// Print a success message for the current download. This will be printed above the progressbar.
pterm.Success.Println("Downloading " + fakeInstallList[i])
// Increment the progressbar by one to indicate progress.
p.Increment()
// Pause for 350 milliseconds to simulate the time taken for each download.
time.Sleep(time.Millisecond * 350)
}
}
```
### progressbar/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer instance from the default one
multi := pterm.DefaultMultiPrinter
// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Loop to increment progress bars based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment the first progress bar at each iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment the third progress bar at every fifth iteration
}
if i%10 == 0 {
pb4.Increment() // Increment the fourth progress bar at every tenth iteration
}
if i%3 == 0 {
pb5.Increment() // Increment the fifth progress bar at every third iteration
}
time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
// Stop the multi printer
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/progressbar/demo/ 0000775 0000000 0000000 00000000000 14650106263 0024130 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/progressbar/demo/README.md 0000664 0000000 0000000 00000002556 14650106263 0025417 0 ustar 00root root 0000000 0000000 # progressbar/demo
```go
package main
import (
"strings"
"time"
"github.com/pterm/pterm"
)
// Slice of strings representing names of pseudo applications to be downloaded.
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", " ")
func main() {
// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
// Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
// Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
// Simulate a slow download for the 7th item.
if i == 6 {
time.Sleep(time.Second * 3)
}
// Update the title of the progressbar with the current item being downloaded.
p.UpdateTitle("Downloading " + fakeInstallList[i])
// Print a success message for the current download. This will be printed above the progressbar.
pterm.Success.Println("Downloading " + fakeInstallList[i])
// Increment the progressbar by one to indicate progress.
p.Increment()
// Pause for 350 milliseconds to simulate the time taken for each download.
time.Sleep(time.Millisecond * 350)
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/progressbar/demo/animation.svg 0000664 0000000 0000000 00000142500 14650106263 0026632 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/progressbar/demo/main.go 0000664 0000000 0000000 00000002462 14650106263 0025407 0 ustar 00root root 0000000 0000000 package main
import (
"strings"
"time"
"github.com/pterm/pterm"
)
// Slice of strings representing names of pseudo applications to be downloaded.
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", " ")
func main() {
// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
// Set the initial title of the progressbar to "Downloading stuff".
p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()
// Loop over each item in the fakeInstallList.
for i := 0; i < p.Total; i++ {
// Simulate a slow download for the 7th item.
if i == 6 {
time.Sleep(time.Second * 3)
}
// Update the title of the progressbar with the current item being downloaded.
p.UpdateTitle("Downloading " + fakeInstallList[i])
// Print a success message for the current download. This will be printed above the progressbar.
pterm.Success.Println("Downloading " + fakeInstallList[i])
// Increment the progressbar by one to indicate progress.
p.Increment()
// Pause for 350 milliseconds to simulate the time taken for each download.
time.Sleep(time.Millisecond * 350)
}
}
golang-github-pterm-pterm-0.12.79/_examples/progressbar/multiple/ 0000775 0000000 0000000 00000000000 14650106263 0025037 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/progressbar/multiple/README.md 0000664 0000000 0000000 00000003116 14650106263 0026317 0 ustar 00root root 0000000 0000000 # progressbar/multiple
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer instance from the default one
multi := pterm.DefaultMultiPrinter
// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Loop to increment progress bars based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment the first progress bar at each iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment the third progress bar at every fifth iteration
}
if i%10 == 0 {
pb4.Increment() // Increment the fourth progress bar at every tenth iteration
}
if i%3 == 0 {
pb5.Increment() // Increment the fifth progress bar at every third iteration
}
time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
// Stop the multi printer
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/progressbar/multiple/animation.svg 0000664 0000000 0000000 00000336575 14650106263 0027562 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/progressbar/multiple/main.go 0000664 0000000 0000000 00000003016 14650106263 0026312 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer instance from the default one
multi := pterm.DefaultMultiPrinter
// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")
// Start the multi printer
multi.Start()
// Loop to increment progress bars based on certain conditions
for i := 1; i <= 100; i++ {
pb1.Increment() // Increment the first progress bar at each iteration
if i%2 == 0 {
pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
}
if i%5 == 0 {
pb3.Increment() // Increment the third progress bar at every fifth iteration
}
if i%10 == 0 {
pb4.Increment() // Increment the fourth progress bar at every tenth iteration
}
if i%3 == 0 {
pb5.Increment() // Increment the fifth progress bar at every third iteration
}
time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
}
// Stop the multi printer
multi.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/section/ 0000775 0000000 0000000 00000000000 14650106263 0022317 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/section/README.md 0000664 0000000 0000000 00000001325 14650106263 0023577 0 ustar 00root root 0000000 0000000 ### section/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
// Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
// Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
// Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
```
golang-github-pterm-pterm-0.12.79/_examples/section/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023243 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/section/demo/README.md 0000664 0000000 0000000 00000001117 14650106263 0024522 0 ustar 00root root 0000000 0000000 # section/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
// Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
// Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
// Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
```
golang-github-pterm-pterm-0.12.79/_examples/section/demo/animation.svg 0000664 0000000 0000000 00000011605 14650106263 0025746 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/section/demo/main.go 0000664 0000000 0000000 00000001027 14650106263 0024516 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Create a section with level one and print it.
pterm.DefaultSection.Println("This is a section!")
// Print an informational message.
pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")
// Create a section with level two and print it.
pterm.DefaultSection.WithLevel(2).Println("This is another section!")
// Print another informational message.
pterm.Info.Println("And this is\nmore placeholder text")
}
golang-github-pterm-pterm-0.12.79/_examples/slog/ 0000775 0000000 0000000 00000000000 14650106263 0021617 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/slog/README.md 0000664 0000000 0000000 00000001754 14650106263 0023105 0 ustar 00root root 0000000 0000000 ### slog/demo
SHOW SOURCE
```go
package main
import (
"log/slog"
"github.com/pterm/pterm"
)
func main() {
// Create a new slog handler with the default PTerm logger
handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
// Create a new slog logger with the handler
logger := slog.New(handler)
// Log a debug message (won't show by default)
logger.Debug("This is a debug message that won't show")
// Change the log level to debug to enable debug messages
pterm.DefaultLogger.Level = pterm.LogLevelDebug
// Log a debug message (will show because debug level is enabled)
logger.Debug("This is a debug message", "changedLevel", true)
// Log an info message
logger.Info("This is an info message")
// Log a warning message
logger.Warn("This is a warning message")
// Log an error message
logger.Error("This is an error message")
}
```
golang-github-pterm-pterm-0.12.79/_examples/slog/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022543 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/slog/demo/README.md 0000664 0000000 0000000 00000001551 14650106263 0024024 0 ustar 00root root 0000000 0000000 # slog/demo
```go
package main
import (
"log/slog"
"github.com/pterm/pterm"
)
func main() {
// Create a new slog handler with the default PTerm logger
handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
// Create a new slog logger with the handler
logger := slog.New(handler)
// Log a debug message (won't show by default)
logger.Debug("This is a debug message that won't show")
// Change the log level to debug to enable debug messages
pterm.DefaultLogger.Level = pterm.LogLevelDebug
// Log a debug message (will show because debug level is enabled)
logger.Debug("This is a debug message", "changedLevel", true)
// Log an info message
logger.Info("This is an info message")
// Log a warning message
logger.Warn("This is a warning message")
// Log an error message
logger.Error("This is an error message")
}
```
golang-github-pterm-pterm-0.12.79/_examples/slog/demo/animation.svg 0000664 0000000 0000000 00000010316 14650106263 0025244 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/slog/demo/main.go 0000664 0000000 0000000 00000001464 14650106263 0024023 0 ustar 00root root 0000000 0000000 package main
import (
"log/slog"
"github.com/pterm/pterm"
)
func main() {
// Create a new slog handler with the default PTerm logger
handler := pterm.NewSlogHandler(&pterm.DefaultLogger)
// Create a new slog logger with the handler
logger := slog.New(handler)
// Log a debug message (won't show by default)
logger.Debug("This is a debug message that won't show")
// Change the log level to debug to enable debug messages
pterm.DefaultLogger.Level = pterm.LogLevelDebug
// Log a debug message (will show because debug level is enabled)
logger.Debug("This is a debug message", "changedLevel", true)
// Log an info message
logger.Info("This is an info message")
// Log a warning message
logger.Warn("This is a warning message")
// Log an error message
logger.Error("This is an error message")
}
golang-github-pterm-pterm-0.12.79/_examples/spinner/ 0000775 0000000 0000000 00000000000 14650106263 0022331 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/spinner/README.md 0000664 0000000 0000000 00000010377 14650106263 0023620 0 ustar 00root root 0000000 0000000 ### spinner/demo
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create and start a fork of the default spinner.
spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerInfo.Info() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerSuccess.Success() // Resolve spinner with success message.
// Create and start a fork of the default spinner.
spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerWarning.Warning() // Resolve spinner with warning message.
// Create and start a fork of the default spinner.
spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerFail.Fail() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
// Replace the InfoPrinter with a custom "NOCHG" one
spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
MessageStyle: &pterm.Style{pterm.FgLightBlue},
Prefix: pterm.Prefix{
Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
Text: " NOCHG ",
},
}
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerNochange.Info("No change were required") // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
```
### spinner/multiple
SHOW SOURCE
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer. This allows multiple spinners to print simultaneously.
multi := pterm.DefaultMultiPrinter
// Create and start spinner 1 with a new writer from the multi printer.
// The spinner will display the message "Spinner 1".
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
// Create and start spinner 2 with a new writer from the multi printer.
// The spinner will display the message "Spinner 2".
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create and start spinner 3 with a new writer from the multi printer.
// The spinner will display the message "Spinner 3".
spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
// Start the multi printer. This will start printing all the spinners.
multi.Start()
// Wait for 1 second.
time.Sleep(time.Millisecond * 1000)
// Stop spinner 1 with a success message.
spinner1.Success("Spinner 1 is done!")
// Wait for 750 milliseconds.
time.Sleep(time.Millisecond * 750)
// Stop spinner 2 with a failure message.
spinner2.Fail("Spinner 2 failed!")
// Wait for 500 milliseconds.
time.Sleep(time.Millisecond * 500)
// Stop spinner 3 with a warning message.
spinner3.Warning("Spinner 3 has a warning!")
// Stop the multi printer. This will stop printing all the spinners.
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/spinner/demo/ 0000775 0000000 0000000 00000000000 14650106263 0023255 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/spinner/demo/README.md 0000664 0000000 0000000 00000004775 14650106263 0024551 0 ustar 00root root 0000000 0000000 # spinner/demo
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create and start a fork of the default spinner.
spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerInfo.Info() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerSuccess.Success() // Resolve spinner with success message.
// Create and start a fork of the default spinner.
spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerWarning.Warning() // Resolve spinner with warning message.
// Create and start a fork of the default spinner.
spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerFail.Fail() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
// Replace the InfoPrinter with a custom "NOCHG" one
spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
MessageStyle: &pterm.Style{pterm.FgLightBlue},
Prefix: pterm.Prefix{
Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
Text: " NOCHG ",
},
}
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerNochange.Info("No change were required") // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
```
golang-github-pterm-pterm-0.12.79/_examples/spinner/demo/animation.svg 0000664 0000000 0000000 00000121663 14650106263 0025766 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/spinner/demo/main.go 0000664 0000000 0000000 00000004705 14650106263 0024536 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create and start a fork of the default spinner.
spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerInfo.Info() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerSuccess.Success() // Resolve spinner with success message.
// Create and start a fork of the default spinner.
spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerWarning.Warning() // Resolve spinner with warning message.
// Create and start a fork of the default spinner.
spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerFail.Fail() // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
// Replace the InfoPrinter with a custom "NOCHG" one
spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
MessageStyle: &pterm.Style{pterm.FgLightBlue},
Prefix: pterm.Prefix{
Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
Text: " NOCHG ",
},
}
time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
spinnerNochange.Info("No change were required") // Resolve spinner with error message.
// Create and start a fork of the default spinner.
spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
golang-github-pterm-pterm-0.12.79/_examples/spinner/multiple/ 0000775 0000000 0000000 00000000000 14650106263 0024164 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/spinner/multiple/README.md 0000664 0000000 0000000 00000002762 14650106263 0025452 0 ustar 00root root 0000000 0000000 # spinner/multiple
```go
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer. This allows multiple spinners to print simultaneously.
multi := pterm.DefaultMultiPrinter
// Create and start spinner 1 with a new writer from the multi printer.
// The spinner will display the message "Spinner 1".
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
// Create and start spinner 2 with a new writer from the multi printer.
// The spinner will display the message "Spinner 2".
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create and start spinner 3 with a new writer from the multi printer.
// The spinner will display the message "Spinner 3".
spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
// Start the multi printer. This will start printing all the spinners.
multi.Start()
// Wait for 1 second.
time.Sleep(time.Millisecond * 1000)
// Stop spinner 1 with a success message.
spinner1.Success("Spinner 1 is done!")
// Wait for 750 milliseconds.
time.Sleep(time.Millisecond * 750)
// Stop spinner 2 with a failure message.
spinner2.Fail("Spinner 2 failed!")
// Wait for 500 milliseconds.
time.Sleep(time.Millisecond * 500)
// Stop spinner 3 with a warning message.
spinner3.Warning("Spinner 3 has a warning!")
// Stop the multi printer. This will stop printing all the spinners.
multi.Stop()
}
```
golang-github-pterm-pterm-0.12.79/_examples/spinner/multiple/animation.svg 0000664 0000000 0000000 00000031664 14650106263 0026676 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/spinner/multiple/main.go 0000664 0000000 0000000 00000002666 14650106263 0025451 0 ustar 00root root 0000000 0000000 package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
// Create a multi printer. This allows multiple spinners to print simultaneously.
multi := pterm.DefaultMultiPrinter
// Create and start spinner 1 with a new writer from the multi printer.
// The spinner will display the message "Spinner 1".
spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
// Create and start spinner 2 with a new writer from the multi printer.
// The spinner will display the message "Spinner 2".
spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")
// Create and start spinner 3 with a new writer from the multi printer.
// The spinner will display the message "Spinner 3".
spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")
// Start the multi printer. This will start printing all the spinners.
multi.Start()
// Wait for 1 second.
time.Sleep(time.Millisecond * 1000)
// Stop spinner 1 with a success message.
spinner1.Success("Spinner 1 is done!")
// Wait for 750 milliseconds.
time.Sleep(time.Millisecond * 750)
// Stop spinner 2 with a failure message.
spinner2.Fail("Spinner 2 failed!")
// Wait for 500 milliseconds.
time.Sleep(time.Millisecond * 500)
// Stop spinner 3 with a warning message.
spinner3.Warning("Spinner 3 has a warning!")
// Stop the multi printer. This will stop printing all the spinners.
multi.Stop()
}
golang-github-pterm-pterm-0.12.79/_examples/style/ 0000775 0000000 0000000 00000000000 14650106263 0022013 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/style/README.md 0000664 0000000 0000000 00000001356 14650106263 0023277 0 ustar 00root root 0000000 0000000 ### style/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
// Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
// Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
// Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/style/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022737 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/style/demo/README.md 0000664 0000000 0000000 00000001152 14650106263 0024215 0 ustar 00root root 0000000 0000000 # style/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
// Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
// Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
// Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
```
golang-github-pterm-pterm-0.12.79/_examples/style/demo/animation.svg 0000664 0000000 0000000 00000004604 14650106263 0025443 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/style/demo/main.go 0000664 0000000 0000000 00000001064 14650106263 0024213 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define a primary style with light cyan foreground, gray background, and bold text
primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
// Define a secondary style with light green foreground, white background, and italic text
secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)
// Print "Hello, World!" with the primary style
primary.Println("Hello, World!")
// Print "Hello, World!" with the secondary style
secondary.Println("Hello, World!")
}
golang-github-pterm-pterm-0.12.79/_examples/table/ 0000775 0000000 0000000 00000000000 14650106263 0021742 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/README.md 0000664 0000000 0000000 00000007632 14650106263 0023231 0 ustar 00root root 0000000 0000000 ### table/demo
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the first table
tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
pterm.Println() // Blank line
// Define the data for the second table
tableData2 := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create another table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
```
### table/boxed
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header of the table.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and is boxed.
// Finally, render the table to print it.
pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
```
### table/multiple-lines
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create and render the table.
// The options are chained in a single line for simplicity.
// The table has a header, a row separator, and a header row separator.
pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
```
### table/right-alignment
SHOW SOURCE
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and the text in the cells is right-aligned.
// The Render() method is used to print the table to the console.
pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/table/boxed/ 0000775 0000000 0000000 00000000000 14650106263 0023043 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/boxed/README.md 0000664 0000000 0000000 00000001423 14650106263 0024322 0 ustar 00root root 0000000 0000000 # table/boxed
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header of the table.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and is boxed.
// Finally, render the table to print it.
pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/table/boxed/animation.svg 0000664 0000000 0000000 00000012704 14650106263 0025547 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/boxed/main.go 0000664 0000000 0000000 00000001334 14650106263 0024317 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header of the table.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and is boxed.
// Finally, render the table to print it.
pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/table/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022666 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/demo/README.md 0000664 0000000 0000000 00000002117 14650106263 0024146 0 ustar 00root root 0000000 0000000 # table/demo
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the first table
tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
pterm.Println() // Blank line
// Define the data for the second table
tableData2 := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create another table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/table/demo/animation.svg 0000664 0000000 0000000 00000015467 14650106263 0025403 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/demo/main.go 0000664 0000000 0000000 00000002031 14650106263 0024135 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the first table
tableData1 := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()
pterm.Println() // Blank line
// Define the data for the second table
tableData2 := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create another table with a header and the defined data, then render it
pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/table/multiple-lines/ 0000775 0000000 0000000 00000000000 14650106263 0024705 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/multiple-lines/README.md 0000664 0000000 0000000 00000001303 14650106263 0026161 0 ustar 00root root 0000000 0000000 # table/multiple-lines
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create and render the table.
// The options are chained in a single line for simplicity.
// The table has a header, a row separator, and a header row separator.
pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/table/multiple-lines/animation.svg 0000664 0000000 0000000 00000013262 14650106263 0027411 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/multiple-lines/main.go 0000664 0000000 0000000 00000001203 14650106263 0026154 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
data := pterm.TableData{
{"Firstname", "Lastname", "Email"},
{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
{"Libby", "Camacho", "lobortis@semper.com"},
{"张", "小宝", "zhang@example.com"},
}
// Create and render the table.
// The options are chained in a single line for simplicity.
// The table has a header, a row separator, and a header row separator.
pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/table/right-alignment/ 0000775 0000000 0000000 00000000000 14650106263 0025033 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/right-alignment/README.md 0000664 0000000 0000000 00000001517 14650106263 0026316 0 ustar 00root root 0000000 0000000 # table/right-alignment
```go
package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and the text in the cells is right-aligned.
// The Render() method is used to print the table to the console.
pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/table/right-alignment/animation.svg 0000664 0000000 0000000 00000010314 14650106263 0027532 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/table/right-alignment/main.go 0000664 0000000 0000000 00000001416 14650106263 0026310 0 ustar 00root root 0000000 0000000 package main
import "github.com/pterm/pterm"
func main() {
// Define the data for the table.
// Each inner slice represents a row in the table.
// The first row is considered as the header.
tableData := pterm.TableData{
{"Firstname", "Lastname", "Email", "Note"},
{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
{"张", "小宝", "zhang@example.com", ""},
}
// Create a table with the defined data.
// The table has a header and the text in the cells is right-aligned.
// The Render() method is used to print the table to the console.
pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/theme/ 0000775 0000000 0000000 00000000000 14650106263 0021755 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/theme/README.md 0000664 0000000 0000000 00000002254 14650106263 0023237 0 ustar 00root root 0000000 0000000 ### theme/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"reflect"
"time"
)
func main() {
// Print an informational message about the default theme styles.
pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
// Print a blank line for better readability.
pterm.Println()
// Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
// Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
// Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
// Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
// Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
// Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/theme/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022701 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/theme/demo/README.md 0000664 0000000 0000000 00000002050 14650106263 0024155 0 ustar 00root root 0000000 0000000 # theme/demo
```go
package main
import (
"github.com/pterm/pterm"
"reflect"
"time"
)
func main() {
// Print an informational message about the default theme styles.
pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
// Print a blank line for better readability.
pterm.Println()
// Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
// Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
// Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
// Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
// Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
// Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
}
```
golang-github-pterm-pterm-0.12.79/_examples/theme/demo/animation.svg 0000664 0000000 0000000 00000157752 14650106263 0025422 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/theme/demo/main.go 0000664 0000000 0000000 00000001762 14650106263 0024162 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"reflect"
"time"
)
func main() {
// Print an informational message about the default theme styles.
pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")
// Print a blank line for better readability.
pterm.Println()
// Get the value and type of the default theme.
v := reflect.ValueOf(pterm.ThemeDefault)
typeOfS := v.Type()
// Check if the type of the default theme is 'pterm.Theme'.
if typeOfS == reflect.TypeOf(pterm.Theme{}) {
// Iterate over each field in the default theme.
for i := 0; i < v.NumField(); i++ {
// Try to convert the field to 'pterm.Style'.
field, ok := v.Field(i).Interface().(pterm.Style)
if ok {
// Print the field name using its own style.
field.Println(typeOfS.Field(i).Name)
}
// Pause for a quarter of a second to make the output easier to read.
time.Sleep(time.Millisecond * 250)
}
}
}
golang-github-pterm-pterm-0.12.79/_examples/tree/ 0000775 0000000 0000000 00000000000 14650106263 0021612 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/tree/README.md 0000664 0000000 0000000 00000004133 14650106263 0023072 0 ustar 00root root 0000000 0000000 ### tree/demo
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
// The top node of the tree
Text: "Top node",
// The children of the top node
Children: []pterm.TreeNode{{
// A child node
Text: "Child node",
// The children of the child node
Children: []pterm.TreeNode{
// Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
},
}},
}
// Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
```
### tree/from-leveled-list
SHOW SOURCE
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
{Level: 0, Text: "C:"},
{Level: 1, Text: "Users"},
{Level: 1, Text: "Windows"},
{Level: 1, Text: "Programs"},
{Level: 1, Text: "Programs(x86)"},
{Level: 1, Text: "dev"},
{Level: 0, Text: "D:"},
{Level: 0, Text: "E:"},
{Level: 1, Text: "Movies"},
{Level: 1, Text: "Music"},
{Level: 2, Text: "LinkinPark"},
{Level: 1, Text: "Games"},
{Level: 2, Text: "Shooter"},
{Level: 3, Text: "CallOfDuty"},
{Level: 3, Text: "CS:GO"},
{Level: 3, Text: "Battlefield"},
{Level: 4, Text: "Battlefield 1"},
{Level: 4, Text: "Battlefield 2"},
{Level: 0, Text: "F:"},
{Level: 1, Text: "dev"},
{Level: 2, Text: "dops"},
{Level: 2, Text: "PTerm"},
}
// Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
root.Text = "Computer" // Set the root node text.
// Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/tree/demo/ 0000775 0000000 0000000 00000000000 14650106263 0022536 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/tree/demo/README.md 0000664 0000000 0000000 00000001222 14650106263 0024012 0 ustar 00root root 0000000 0000000 # tree/demo
```go
package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
// The top node of the tree
Text: "Top node",
// The children of the top node
Children: []pterm.TreeNode{{
// A child node
Text: "Child node",
// The children of the child node
Children: []pterm.TreeNode{
// Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
},
}},
}
// Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/tree/demo/animation.svg 0000664 0000000 0000000 00000005572 14650106263 0025247 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/tree/demo/main.go 0000664 0000000 0000000 00000001135 14650106263 0024011 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
)
func main() {
// Define a tree structure using pterm.TreeNode
tree := pterm.TreeNode{
// The top node of the tree
Text: "Top node",
// The children of the top node
Children: []pterm.TreeNode{{
// A child node
Text: "Child node",
// The children of the child node
Children: []pterm.TreeNode{
// Grandchildren nodes
{Text: "Grandchild node"},
{Text: "Grandchild node"},
{Text: "Grandchild node"},
},
}},
}
// Render the tree with the defined structure as the root
pterm.DefaultTree.WithRoot(tree).Render()
}
golang-github-pterm-pterm-0.12.79/_examples/tree/from-leveled-list/ 0000775 0000000 0000000 00000000000 14650106263 0025144 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/tree/from-leveled-list/README.md 0000664 0000000 0000000 00000002266 14650106263 0026431 0 ustar 00root root 0000000 0000000 # tree/from-leveled-list
```go
package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
{Level: 0, Text: "C:"},
{Level: 1, Text: "Users"},
{Level: 1, Text: "Windows"},
{Level: 1, Text: "Programs"},
{Level: 1, Text: "Programs(x86)"},
{Level: 1, Text: "dev"},
{Level: 0, Text: "D:"},
{Level: 0, Text: "E:"},
{Level: 1, Text: "Movies"},
{Level: 1, Text: "Music"},
{Level: 2, Text: "LinkinPark"},
{Level: 1, Text: "Games"},
{Level: 2, Text: "Shooter"},
{Level: 3, Text: "CallOfDuty"},
{Level: 3, Text: "CS:GO"},
{Level: 3, Text: "Battlefield"},
{Level: 4, Text: "Battlefield 1"},
{Level: 4, Text: "Battlefield 2"},
{Level: 0, Text: "F:"},
{Level: 1, Text: "dev"},
{Level: 2, Text: "dops"},
{Level: 2, Text: "PTerm"},
}
// Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
root.Text = "Computer" // Set the root node text.
// Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
```
golang-github-pterm-pterm-0.12.79/_examples/tree/from-leveled-list/animation.svg 0000664 0000000 0000000 00000015760 14650106263 0027655 0 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/_examples/tree/from-leveled-list/main.go 0000664 0000000 0000000 00000002164 14650106263 0026422 0 ustar 00root root 0000000 0000000 package main
import (
"github.com/pterm/pterm"
"github.com/pterm/pterm/putils"
)
func main() {
// Define a leveled list to represent the structure of the directories.
leveledList := pterm.LeveledList{
{Level: 0, Text: "C:"},
{Level: 1, Text: "Users"},
{Level: 1, Text: "Windows"},
{Level: 1, Text: "Programs"},
{Level: 1, Text: "Programs(x86)"},
{Level: 1, Text: "dev"},
{Level: 0, Text: "D:"},
{Level: 0, Text: "E:"},
{Level: 1, Text: "Movies"},
{Level: 1, Text: "Music"},
{Level: 2, Text: "LinkinPark"},
{Level: 1, Text: "Games"},
{Level: 2, Text: "Shooter"},
{Level: 3, Text: "CallOfDuty"},
{Level: 3, Text: "CS:GO"},
{Level: 3, Text: "Battlefield"},
{Level: 4, Text: "Battlefield 1"},
{Level: 4, Text: "Battlefield 2"},
{Level: 0, Text: "F:"},
{Level: 1, Text: "dev"},
{Level: 2, Text: "dops"},
{Level: 2, Text: "PTerm"},
}
// Convert the leveled list into a tree structure.
root := putils.TreeFromLeveledList(leveledList)
root.Text = "Computer" // Set the root node text.
// Render the tree structure using the default tree printer.
pterm.DefaultTree.WithRoot(root).Render()
}
golang-github-pterm-pterm-0.12.79/area_printer.go 0000664 0000000 0000000 00000006365 14650106263 0021712 0 ustar 00root root 0000000 0000000 package pterm
import (
"io"
"strings"
"atomicgo.dev/cursor"
"github.com/pterm/pterm/internal"
)
// DefaultArea is the default area printer.
var DefaultArea = AreaPrinter{}
// AreaPrinter prints an area which can be updated easily.
// use this printer for live output like charts, algorithm visualizations, simulations and even games.
type AreaPrinter struct {
RemoveWhenDone bool
Fullscreen bool
Center bool
content string
isActive bool
area *cursor.Area
}
// GetContent returns the current area content.
func (p *AreaPrinter) GetContent() string {
return p.content
}
// WithRemoveWhenDone removes the AreaPrinter content after it is stopped.
func (p AreaPrinter) WithRemoveWhenDone(b ...bool) *AreaPrinter {
p.RemoveWhenDone = internal.WithBoolean(b)
return &p
}
// WithFullscreen sets the AreaPrinter height the same height as the terminal, making it fullscreen.
func (p AreaPrinter) WithFullscreen(b ...bool) *AreaPrinter {
p.Fullscreen = internal.WithBoolean(b)
return &p
}
// WithCenter centers the AreaPrinter content to the terminal.
func (p AreaPrinter) WithCenter(b ...bool) *AreaPrinter {
p.Center = internal.WithBoolean(b)
return &p
}
// SetWriter sets the writer for the AreaPrinter.
func (p *AreaPrinter) SetWriter(writer io.Writer) {
}
// Update overwrites the content of the AreaPrinter.
// Can be used live.
func (p *AreaPrinter) Update(text ...interface{}) {
if p.area == nil {
newArea := cursor.NewArea()
p.area = &newArea
}
str := Sprint(text...)
p.content = str
if p.Center {
str = DefaultCenter.Sprint(str)
}
if p.Fullscreen {
str = strings.TrimRight(str, "\n")
height := GetTerminalHeight()
contentHeight := strings.Count(str, "\n")
topPadding := 0
bottomPadding := height - contentHeight - 2
if p.Center {
topPadding = (bottomPadding / 2) + 1
bottomPadding /= 2
}
if height > contentHeight {
str = strings.Repeat("\n", topPadding) + str
str += strings.Repeat("\n", bottomPadding)
}
}
p.area.Update(str)
}
// Start the AreaPrinter.
func (p *AreaPrinter) Start(text ...interface{}) (*AreaPrinter, error) {
p.isActive = true
str := Sprint(text...)
newArea := cursor.NewArea()
p.area = &newArea
p.Update(str)
return p, nil
}
// Stop terminates the AreaPrinter immediately.
// The AreaPrinter will not resolve into anything.
func (p *AreaPrinter) Stop() error {
if !p.isActive {
return nil
}
p.isActive = false
if p.RemoveWhenDone {
p.Clear()
}
return nil
}
// GenericStart runs Start, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Start instead of this in your program.
func (p *AreaPrinter) GenericStart() (*LivePrinter, error) {
_, _ = p.Start()
lp := LivePrinter(p)
return &lp, nil
}
// GenericStop runs Stop, but returns a LivePrinter.
// This is used for the interface LivePrinter.
// You most likely want to use Stop instead of this in your program.
func (p *AreaPrinter) GenericStop() (*LivePrinter, error) {
_ = p.Stop()
lp := LivePrinter(p)
return &lp, nil
}
// Clear is a Wrapper function that clears the content of the Area
// moves the cursor to the bottom of the terminal, clears n lines upwards from
// the current position and moves the cursor again.
func (p *AreaPrinter) Clear() {
p.area.Clear()
}
golang-github-pterm-pterm-0.12.79/area_printer_test.go 0000664 0000000 0000000 00000006441 14650106263 0022744 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestAreaPrinter_NilPrint(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.AreaPrinter{}
p.Update("asd")
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_GenericStart(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.DefaultArea
p.GenericStart()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_GenericStartRawOutput(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
pterm.DisableStyling()
p := pterm.DefaultArea
p.GenericStart()
pterm.EnableStyling()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_GenericStop(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.DefaultArea
p.GenericStop()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_RemoveWhenDone(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
a, _ := pterm.DefaultArea.WithRemoveWhenDone().Start()
a.Update("asd")
a.Stop()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_CenterFullscreen(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
a, _ := pterm.DefaultArea.WithRemoveWhenDone().WithFullscreen().WithCenter().Start()
a.Update("asd")
a.Stop()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_GetContent(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
a, _ := pterm.DefaultArea.Start()
for _, printable := range printables {
a.Update(printable)
testza.AssertEqual(t, a.GetContent(), pterm.Sprint(printable))
}
a.Stop()
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_WithRemoveWhenDone(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.AreaPrinter{}
p2 := p.WithRemoveWhenDone()
testza.AssertTrue(t, p2.RemoveWhenDone)
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_WithFullscreen(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.AreaPrinter{}
p2 := p.WithFullscreen()
testza.AssertTrue(t, p2.Fullscreen)
os.Stdout = originalStdout // Restore original os.Stdout
}
func TestAreaPrinter_Clear(t *testing.T) {
originalStdout := os.Stdout
os.Stdout = os.NewFile(0, os.DevNull) // Set os.Stdout to DevNull to hide output from cursor.Area
p := pterm.AreaPrinter{}
p.Update("asd")
p.Clear()
os.Stdout = originalStdout // Restore original os.Stdout
}
golang-github-pterm-pterm-0.12.79/atoms.go 0000664 0000000 0000000 00000001514 14650106263 0020351 0 ustar 00root root 0000000 0000000 package pterm
// Checkmark is used in the interactive multiselect printer.
type Checkmark struct {
Checked string
Unchecked string
}
// Bars is used to display multiple Bar.
type Bars []Bar
// Bar is used in bar charts.
type Bar struct {
Label string
Value int
Style *Style
LabelStyle *Style
}
// WithLabel returns a new Bar with a specific option.
func (p Bar) WithLabel(s string) *Bar {
p.Label = s
return &p
}
// WithLabelStyle returns a new Bar with a specific option.
func (p Bar) WithLabelStyle(style *Style) *Bar {
p.LabelStyle = style
return &p
}
// WithValue returns a new Bar with a specific option.
func (p Bar) WithValue(value int) *Bar {
p.Value = value
return &p
}
// WithStyle returns a new Bar with a specific option.
func (p Bar) WithStyle(style *Style) *Bar {
p.Style = style
return &p
}
golang-github-pterm-pterm-0.12.79/atoms_test.go 0000664 0000000 0000000 00000001540 14650106263 0021407 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBar_WithLabel(t *testing.T) {
p := pterm.Bar{}
s := "X"
p2 := p.WithLabel(s)
testza.AssertEqual(t, s, p2.Label)
testza.AssertZero(t, p.Label)
}
func TestBar_WithStyle(t *testing.T) {
p := pterm.Bar{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold)
p2 := p.WithStyle(s)
testza.AssertEqual(t, s, p2.Style)
testza.AssertZero(t, p.Style)
}
func TestBar_WithValue(t *testing.T) {
p := pterm.Bar{}
s := 1337
p2 := p.WithValue(s)
testza.AssertEqual(t, s, p2.Value)
testza.AssertZero(t, p.Value)
}
func TestBar_WithLabelStyle(t *testing.T) {
p := pterm.Bar{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold)
p2 := p.WithLabelStyle(s)
testza.AssertEqual(t, s, p2.LabelStyle)
testza.AssertZero(t, p.LabelStyle)
}
golang-github-pterm-pterm-0.12.79/barchart.go 0000664 0000000 0000000 00000031607 14650106263 0021022 0 ustar 00root root 0000000 0000000 package pterm
import (
"io"
"strconv"
"strings"
"github.com/mattn/go-runewidth"
"github.com/pterm/pterm/internal"
)
// BarChartPrinter is used to print bar charts.
type BarChartPrinter struct {
Writer io.Writer
Bars Bars
Horizontal bool
ShowValue bool
// Height sets the maximum height of a vertical bar chart.
// The default is calculated to fit into the terminal.
// Ignored if Horizontal is set to true.
Height int
// Width sets the maximum width of a horizontal bar chart.
// The default is calculated to fit into the terminal.
// Ignored if Horizontal is set to false.
Width int
VerticalBarCharacter string
HorizontalBarCharacter string
}
var (
// DefaultBarChart is the default BarChartPrinter.
DefaultBarChart = BarChartPrinter{
Horizontal: false,
VerticalBarCharacter: "██",
HorizontalBarCharacter: "█",
// keep in sync with RecalculateTerminalSize()
Height: GetTerminalHeight() * 2 / 3,
Width: GetTerminalWidth() * 2 / 3,
}
)
// WithBars returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithBars(bars Bars) *BarChartPrinter {
p.Bars = bars
return &p
}
// WithVerticalBarCharacter returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithVerticalBarCharacter(char string) *BarChartPrinter {
p.VerticalBarCharacter = char
return &p
}
// WithHorizontalBarCharacter returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithHorizontalBarCharacter(char string) *BarChartPrinter {
p.HorizontalBarCharacter = char
return &p
}
// WithHorizontal returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithHorizontal(b ...bool) *BarChartPrinter {
b2 := internal.WithBoolean(b)
p.Horizontal = b2
return &p
}
// WithHeight returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithHeight(value int) *BarChartPrinter {
p.Height = value
return &p
}
// WithWidth returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithWidth(value int) *BarChartPrinter {
p.Width = value
return &p
}
// WithShowValue returns a new BarChartPrinter with a specific option.
func (p BarChartPrinter) WithShowValue(b ...bool) *BarChartPrinter {
p.ShowValue = internal.WithBoolean(b)
return &p
}
// WithWriter sets the custom Writer.
func (p BarChartPrinter) WithWriter(writer io.Writer) *BarChartPrinter {
p.Writer = writer
return &p
}
func (p BarChartPrinter) getRawOutput() string {
var ret string
for _, bar := range p.Bars {
ret += Sprintfln("%s: %d", bar.Label, bar.Value)
}
return ret
}
// Srender renders the BarChart as a string.
func (p BarChartPrinter) Srender() (string, error) {
maxAbsValue := func(value1 int, value2 int) int {
min := value1
max := value2
if value1 > value2 {
min = value2
max = value1
}
maxAbs := max
if min < 0 && -min > max { // This is to avoid something like "int(math.Abs(float64(minBarValue)))"
maxAbs = -min // (--) == (+)
}
return maxAbs
}
abs := func(value int) int {
if value < 0 {
return -value
}
return value
}
// =================================== VERTICAL BARS RENDERER ======================================================
type renderParams struct {
repeatCount int
bar Bar
positiveChartPartHeight int
negativeChartPartHeight int
positiveChartPartWidth int
negativeChartPartWidth int
indent string
showValue bool
moveUp bool
moveRight bool
}
renderPositiveVerticalBar := func(renderedBarRef *string, rParams renderParams) {
if rParams.showValue {
*renderedBarRef += Sprint(rParams.indent + strconv.Itoa(rParams.bar.Value) + rParams.indent + "\n")
}
for i := rParams.positiveChartPartHeight; i > 0; i-- {
if i > rParams.repeatCount {
*renderedBarRef += rParams.indent + " " + rParams.indent + " \n"
} else {
*renderedBarRef += rParams.indent + rParams.bar.Style.Sprint(p.VerticalBarCharacter) + rParams.indent + " \n"
}
}
// Used when we draw diagram with both POSITIVE and NEGATIVE values.
// In such case we separately draw top and bottom half of chart.
// And we need MOVE UP positive part to top part of chart,
// technically by adding empty pillars with height == height of chart's bottom part.
if rParams.moveUp {
for i := 0; i <= rParams.negativeChartPartHeight; i++ {
*renderedBarRef += rParams.indent + " " + rParams.indent + " \n"
}
}
}
renderNegativeVerticalBar := func(renderedBarRef *string, rParams renderParams) {
for i := 0; i > -rParams.negativeChartPartHeight; i-- {
if i > rParams.repeatCount {
*renderedBarRef += rParams.indent + rParams.bar.Style.Sprint(p.VerticalBarCharacter) + rParams.indent + " \n"
} else {
*renderedBarRef += rParams.indent + " " + rParams.indent + " \n"
}
}
if rParams.showValue {
*renderedBarRef += Sprint(rParams.indent + strconv.Itoa(rParams.bar.Value) + rParams.indent + "\n")
}
}
// =================================== HORIZONTAL BARS RENDERER ====================================================
renderPositiveHorizontalBar := func(renderedBarRef *string, rParams renderParams) {
if rParams.moveRight {
for i := 0; i < rParams.negativeChartPartWidth; i++ {
*renderedBarRef += " "
}
}
for i := 0; i < rParams.positiveChartPartWidth; i++ {
if i < rParams.repeatCount {
*renderedBarRef += rParams.bar.Style.Sprint(p.HorizontalBarCharacter)
} else {
*renderedBarRef += " "
}
}
if rParams.showValue {
// For positive horizontal bars we add one more space before adding value,
// so they will be well aligned with negative values, which have "-" sign before them
*renderedBarRef += " "
*renderedBarRef += " " + strconv.Itoa(rParams.bar.Value)
}
}
renderNegativeHorizontalBar := func(renderedBarRef *string, rParams renderParams) {
for i := -rParams.negativeChartPartWidth; i < 0; i++ {
if i < rParams.repeatCount {
*renderedBarRef += " "
} else {
*renderedBarRef += rParams.bar.Style.Sprint(p.HorizontalBarCharacter)
}
}
// In order to print values well-aligned (in case when we have both - positive and negative part of chart),
// we should insert an indent with width == width of positive chart part
if rParams.positiveChartPartWidth > 0 {
for i := 0; i < rParams.positiveChartPartWidth; i++ {
*renderedBarRef += " "
}
}
if rParams.showValue {
/*
This is in order to achieve this effect:
0
-15
0
-19
INSTEAD OF THIS:
0
-15
0
-19
*/
if rParams.repeatCount == 0 {
*renderedBarRef += " "
}
*renderedBarRef += " " + strconv.Itoa(rParams.bar.Value)
}
}
// =================================================================================================================
if RawOutput {
return p.getRawOutput(), nil
}
for i, bar := range p.Bars {
if bar.Style == nil {
p.Bars[i].Style = &ThemeDefault.BarStyle
}
if bar.LabelStyle == nil {
p.Bars[i].LabelStyle = &ThemeDefault.BarLabelStyle
}
p.Bars[i].Label = p.Bars[i].LabelStyle.Sprint(bar.Label)
}
var ret string
var maxLabelHeight int
var maxBarValue int
var minBarValue int
var maxAbsBarValue int
var rParams renderParams
for _, bar := range p.Bars {
if bar.Value > maxBarValue {
maxBarValue = bar.Value
}
if bar.Value < minBarValue {
minBarValue = bar.Value
}
labelHeight := len(strings.Split(bar.Label, "\n"))
if labelHeight > maxLabelHeight {
maxLabelHeight = labelHeight
}
}
maxAbsBarValue = maxAbsValue(maxBarValue, minBarValue)
if p.Horizontal {
panels := Panels{[]Panel{{}, {}}}
rParams.showValue = p.ShowValue
rParams.positiveChartPartWidth = p.Width
rParams.negativeChartPartWidth = p.Width
// If chart will consist of two parts - positive and negative - we should recalculate max bars WIDTH in LEFT and RIGHT parts
if minBarValue < 0 && maxBarValue > 0 {
rParams.positiveChartPartWidth = abs(internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Width)/2, float32(p.Width)/2, float32(maxBarValue)))
rParams.negativeChartPartWidth = abs(internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Width)/2, float32(p.Width)/2, float32(minBarValue)))
}
for _, bar := range p.Bars {
rParams.bar = bar
panels[0][0].Data += "\n" + bar.Label
panels[0][1].Data += "\n"
if minBarValue >= 0 {
// As we don't have negative values, draw only positive (right) part of the chart:
rParams.repeatCount = internal.MapRangeToRange(0, float32(maxAbsBarValue), 0, float32(p.Width), float32(bar.Value))
rParams.moveRight = false
renderPositiveHorizontalBar(&panels[0][1].Data, rParams)
} else if maxBarValue <= 0 {
// As we have only negative values, draw only negative (left) part of the chart:
rParams.repeatCount = internal.MapRangeToRange(-float32(maxAbsBarValue), 0, -float32(p.Width), 0, float32(bar.Value))
rParams.positiveChartPartWidth = 0
renderNegativeHorizontalBar(&panels[0][1].Data, rParams)
} else {
// We have positive and negative values, so draw both (left+right) parts of the chart:
rParams.repeatCount = internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Width)/2, float32(p.Width)/2, float32(bar.Value))
if bar.Value >= 0 {
rParams.moveRight = true
renderPositiveHorizontalBar(&panels[0][1].Data, rParams)
}
if bar.Value < 0 {
renderNegativeHorizontalBar(&panels[0][1].Data, rParams)
}
}
}
ret, _ = DefaultPanel.WithPanels(panels).Srender()
return ret, nil
} else {
renderedBars := make([]string, len(p.Bars))
rParams.showValue = p.ShowValue
rParams.positiveChartPartHeight = p.Height
rParams.negativeChartPartHeight = p.Height
// If chart will consist of two parts - positive and negative - we should recalculate max bars height in top and bottom parts
if minBarValue < 0 && maxBarValue > 0 {
rParams.positiveChartPartHeight = abs(internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Height)/2, float32(p.Height)/2, float32(maxBarValue)))
rParams.negativeChartPartHeight = abs(internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Height)/2, float32(p.Height)/2, float32(minBarValue)))
}
for i, bar := range p.Bars {
var renderedBar string
rParams.bar = bar
rParams.indent = strings.Repeat(" ", internal.GetStringMaxWidth(RemoveColorFromString(bar.Label))/2)
if minBarValue >= 0 {
// As we don't have negative values, draw only positive (top) part of the chart:
rParams.repeatCount = internal.MapRangeToRange(0, float32(maxAbsBarValue), 0, float32(p.Height), float32(bar.Value))
rParams.moveUp = false // Don't MOVE UP as we have ONLY positive part of chart.
renderPositiveVerticalBar(&renderedBar, rParams)
} else if maxBarValue <= 0 {
// As we have only negative values, draw only negative (bottom) part of the chart:
rParams.repeatCount = internal.MapRangeToRange(-float32(maxAbsBarValue), 0, -float32(p.Height), 0, float32(bar.Value))
renderNegativeVerticalBar(&renderedBar, rParams)
} else {
// We have positive and negative values, so draw both (top+bottom) parts of the chart:
rParams.repeatCount = internal.MapRangeToRange(-float32(maxAbsBarValue), float32(maxAbsBarValue), -float32(p.Height)/2, float32(p.Height)/2, float32(bar.Value))
if bar.Value >= 0 {
rParams.moveUp = true // MOVE UP positive part, because we have both positive and negative parts of chart.
renderPositiveVerticalBar(&renderedBar, rParams)
}
if bar.Value < 0 {
renderNegativeVerticalBar(&renderedBar, rParams)
}
}
labelHeight := len(strings.Split(bar.Label, "\n"))
renderedBars[i] = renderedBar + bar.Label + strings.Repeat("\n", maxLabelHeight-labelHeight) + " "
}
var maxBarHeight int
for _, bar := range renderedBars {
totalBarHeight := len(strings.Split(bar, "\n"))
if totalBarHeight > maxBarHeight {
maxBarHeight = totalBarHeight
}
}
for i, bar := range renderedBars {
totalBarHeight := len(strings.Split(bar, "\n"))
if totalBarHeight < maxBarHeight {
renderedBars[i] = strings.Repeat("\n", maxBarHeight-totalBarHeight) + renderedBars[i]
}
}
for i := 0; i <= maxBarHeight; i++ {
for _, barString := range renderedBars {
var barLine string
letterLines := strings.Split(barString, "\n")
maxBarWidth := internal.GetStringMaxWidth(RemoveColorFromString(barString))
if len(letterLines) > i {
barLine = letterLines[i]
}
letterLineLength := runewidth.StringWidth(RemoveColorFromString(barLine))
if letterLineLength < maxBarWidth {
barLine += strings.Repeat(" ", maxBarWidth-letterLineLength)
}
ret += barLine
}
ret += "\n"
}
}
return ret, nil
}
// Render prints the Template to the terminal.
func (p BarChartPrinter) Render() error {
s, _ := p.Srender()
Fprintln(p.Writer, s)
return nil
}
golang-github-pterm-pterm-0.12.79/barchart_test.go 0000664 0000000 0000000 00000023737 14650106263 0022066 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBarChartPrinterNilPrint(t *testing.T) {
proxyToDevNull()
p := pterm.BarChartPrinter{}
err := p.Render()
if err != nil {
panic(err)
}
}
func TestBarChartPrinter_NilStylePrint(t *testing.T) {
bars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.DefaultBarChart.WithBars(bars).Render()
}
// VERTICAL bars + MIXED values test
func TestBarChartPrinter_RenderExample(t *testing.T) {
bars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Long Label Example",
Value: 7,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Zero",
Value: 0,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Negative Value",
Value: -4,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "NV",
Value: -5,
Style: pterm.NewStyle(pterm.FgCyan),
},
}
pterm.DefaultBarChart.WithBars(bars).Render()
}
// VERTICAL bars + NEGATIVE values test
func TestBarChartPrinter_RenderNegativeBarValues(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: -1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -1000,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -950,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -1500,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -10,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -100,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// VERTICAL bars + POSITIVE values test
func TestBarChartPrinter_RenderPositiveBarValues(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 1000,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 1400,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 900,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// VERTICAL bars + ZERO values test
func TestBarChartPrinter_RenderZeroBarValues(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// HORIZONTAL bars + MIXED values test
func TestBarChartPrinter_RenderExampleHorizontal(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithHorizontal().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 1000,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Zero",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -800,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -500,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// HORIZONTAL bars + NEGATIVE values test
func TestBarChartPrinter_RenderNegativeBarValuesHorizontal(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithHorizontal().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: -999,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -500,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -653,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -20,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -100,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -30,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// HORIZONTAL bars + POSITIVE values test
func TestBarChartPrinter_RenderPositiveBarValuesHorizontal(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithHorizontal().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 30,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 70,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 80,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 90,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 40,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 30,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
// HORIZONTAL bars + ZERO values test
func TestBarChartPrinter_RenderZeroBarValuesHorizontal(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithHorizontal().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 0,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
func TestBarChartPrinter_RenderExampleRawOutput(t *testing.T) {
pterm.DisableStyling()
bars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Long Label Example",
Value: 7,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Zero",
Value: 0,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "Negative Value",
Value: -4,
Style: pterm.NewStyle(pterm.FgCyan),
},
pterm.Bar{
Label: "NV",
Value: -5,
Style: pterm.NewStyle(pterm.FgCyan),
},
}
pterm.DefaultBarChart.WithBars(bars).Render()
pterm.EnableStyling()
}
func TestBarChartPrinter_RenderMultipleLineLabel(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: -1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test\nNew Line",
Value: -1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: -1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
func TestBarChartPrinter_RenderLowBarValues(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 1,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 1,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
func TestBarChartPrinter_Render(t *testing.T) {
pterm.DefaultBarChart.WithShowValue().WithBars(pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}).Render()
}
func TestBarChartPrinter_WithHorizontalBarCharacter(t *testing.T) {
p := pterm.BarChartPrinter{}
s := "X"
p2 := p.WithHorizontalBarCharacter(s)
testza.AssertEqual(t, s, p2.HorizontalBarCharacter)
testza.AssertZero(t, p.HorizontalBarCharacter)
}
func TestBarChartPrinter_WithVerticalBarCharacter(t *testing.T) {
p := pterm.BarChartPrinter{}
s := "X"
p2 := p.WithVerticalBarCharacter(s)
testza.AssertEqual(t, s, p2.VerticalBarCharacter)
testza.AssertZero(t, p.VerticalBarCharacter)
}
func TestBarChartPrinter_WithBars(t *testing.T) {
p := pterm.BarChartPrinter{}
s := pterm.Bars{
pterm.Bar{
Label: "Test",
Value: 1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Bar{
Label: "Test",
Value: 1337,
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}
p2 := p.WithBars(s)
testza.AssertEqual(t, s, p2.Bars)
testza.AssertZero(t, p.Bars)
}
func TestBarChartPrinter_WithHeight(t *testing.T) {
p := pterm.BarChartPrinter{}
s := 1337
p2 := p.WithHeight(s)
testza.AssertEqual(t, s, p2.Height)
testza.AssertZero(t, p.Height)
}
func TestBarChartPrinter_WithHorizontal(t *testing.T) {
p := pterm.BarChartPrinter{}
s := true
p2 := p.WithHorizontal(s)
testza.AssertEqual(t, s, p2.Horizontal)
testza.AssertZero(t, p.Horizontal)
}
func TestBarChartPrinter_WithShowValue(t *testing.T) {
p := pterm.BarChartPrinter{}
s := true
p2 := p.WithShowValue(s)
testza.AssertEqual(t, s, p2.ShowValue)
testza.AssertZero(t, p.ShowValue)
}
func TestBarChartPrinter_WithWidth(t *testing.T) {
p := pterm.BarChartPrinter{}
s := 1337
p2 := p.WithWidth(s)
testza.AssertEqual(t, s, p2.Width)
testza.AssertZero(t, p.Width)
}
func TestBarChartPrinter_WithWriter(t *testing.T) {
p := pterm.BarChartPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/basic_text_printer.go 0000664 0000000 0000000 00000007612 14650106263 0023123 0 ustar 00root root 0000000 0000000 package pterm
import (
"fmt"
"io"
)
var (
// DefaultBasicText returns a default BasicTextPrinter, which can be used to print text as is.
// No default style is present for BasicTextPrinter.
DefaultBasicText = BasicTextPrinter{}
)
// BasicTextPrinter is the printer used to print the input as-is or as specified by user formatting.
type BasicTextPrinter struct {
Style *Style
Writer io.Writer
}
// WithStyle adds a style to the printer.
func (p BasicTextPrinter) WithStyle(style *Style) *BasicTextPrinter {
p.Style = style
return &p
}
func (p BasicTextPrinter) WithWriter(writer io.Writer) *BasicTextPrinter {
p.Writer = writer
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 BasicTextPrinter) Sprint(a ...interface{}) string {
if p.Style == nil {
p.Style = NewStyle()
}
return p.Style.Sprint(a...)
}
// 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 BasicTextPrinter) Sprintln(a ...interface{}) string {
str := fmt.Sprintln(a...)
return Sprintln(p.Sprint(str))
}
// Sprintf formats according to a format specifier and returns the resulting string.
func (p BasicTextPrinter) 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 BasicTextPrinter) Sprintfln(format string, a ...interface{}) string {
return p.Sprintf(format, a...) + "\n"
}
// Print formats using the default formats for its operands and writes to provided writer.
// Spaces are added between operands when neither is a string.
// It returns the number of bytes written and any write error encountered.
func (p *BasicTextPrinter) Print(a ...interface{}) *TextPrinter {
Fprint(p.Writer, p.Sprint(a...))
tp := TextPrinter(p)
return &tp
}
// Println formats using the default formats for its operands and writes to provided writer.
// 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 *BasicTextPrinter) Println(a ...interface{}) *TextPrinter {
Fprint(p.Writer, p.Sprintln(a...))
tp := TextPrinter(p)
return &tp
}
// Printf formats according to a format specifier and writes to provided writer.
// It returns the number of bytes written and any write error encountered.
func (p *BasicTextPrinter) Printf(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, p.Sprintf(format, a...))
tp := TextPrinter(p)
return &tp
}
// Printfln formats according to a format specifier and writes to provided writer.
// 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 *BasicTextPrinter) Printfln(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 *BasicTextPrinter) 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 *BasicTextPrinter) 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
}
golang-github-pterm-pterm-0.12.79/basic_text_printer_test.go 0000664 0000000 0000000 00000005042 14650106263 0024155 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"errors"
"io"
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBasicTextPrinterNilPrint(t *testing.T) {
proxyToDevNull()
p := pterm.BasicTextPrinter{}
p.Println("Hello, World!")
}
func TestBasicTextPrinterPrintMethods(t *testing.T) {
p := pterm.DefaultBasicText
t.Run("Print", func(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
p.Print(a)
})
})
t.Run("Printf", func(t *testing.T) {
testPrintfContains(t, func(w io.Writer, format string, a interface{}) {
p.Printf(format, a)
})
})
t.Run("Printfln", func(t *testing.T) {
testPrintflnContains(t, func(w io.Writer, format string, a interface{}) {
p.Printfln(format, a)
})
})
t.Run("Println", func(t *testing.T) {
testPrintlnContains(t, func(w io.Writer, a interface{}) {
p.Println(a)
})
})
t.Run("Sprint", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint(a)
})
})
t.Run("Sprintf", func(t *testing.T) {
testSprintfContains(t, func(format string, a interface{}) string {
return p.Sprintf(format, a)
})
})
t.Run("Sprintfln", func(t *testing.T) {
testSprintflnContains(t, func(format string, a interface{}) string {
return p.Sprintfln(format, a)
})
})
t.Run("Sprintln", func(t *testing.T) {
testSprintlnContains(t, func(a interface{}) string {
return p.Sprintln(a)
})
})
t.Run("PrintOnError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(nil)
})
testza.AssertZero(t, result)
})
t.Run("PrintOnErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("wrapping error : %w", errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("", nil)
})
testza.AssertZero(t, result)
})
}
func TestBasicTextPrinter_WithStyle(t *testing.T) {
s := pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold)
p := pterm.BasicTextPrinter{}
p2 := p.WithStyle(s)
testza.AssertEqual(t, s, p2.Style)
}
func TestBasicTextPrinter_WithWriter(t *testing.T) {
p := pterm.BasicTextPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/bigtext_printer.go 0000664 0000000 0000000 00000024511 14650106263 0022441 0 ustar 00root root 0000000 0000000 package pterm
import (
"io"
"strings"
"github.com/gookit/color"
"github.com/mattn/go-runewidth"
"github.com/pterm/pterm/internal"
)
// Letters is a slice of Letter.
type Letters []Letter
// Letter is an object, which holds a string and a specific Style for it.
type Letter struct {
String string
Style *Style
RGB RGB
}
// WithStyle returns a new Letter with a specific Style.
func (l Letter) WithStyle(style *Style) *Letter {
l.Style = style
return &l
}
// WithRGB returns a new Letter with a specific RGB color (overwrites style).
func (l Letter) WithRGB(rgb RGB) *Letter {
l.RGB = rgb
return &l
}
// WithString returns a new Letter with a specific String.
func (l Letter) WithString(s string) *Letter {
l.String = s
return &l
}
// BigTextPrinter renders big text.
// You can use this as title screen for your application.
type BigTextPrinter struct {
// BigCharacters holds the map from a normal character to it's big version.
BigCharacters map[string]string
Letters Letters
Writer io.Writer
}
// WithBigCharacters returns a new BigTextPrinter with specific BigCharacters.
func (p BigTextPrinter) WithBigCharacters(chars map[string]string) *BigTextPrinter {
p.BigCharacters = chars
return &p
}
// WithLetters returns a new BigTextPrinter with specific Letters
func (p BigTextPrinter) WithLetters(letters ...Letters) *BigTextPrinter {
l := Letters{}
for _, letter := range letters {
l = append(l, letter...)
}
p.Letters = l
return &p
}
// WithWriter sets the custom Writer.
func (p BigTextPrinter) WithWriter(writer io.Writer) *BigTextPrinter {
p.Writer = writer
return &p
}
// Srender renders the BigText as a string.
func (p BigTextPrinter) Srender() (string, error) {
var ret string
if RawOutput {
for _, letter := range p.Letters {
ret += letter.String
}
return ret, nil
}
var bigLetters Letters
for _, l := range p.Letters {
if val, ok := p.BigCharacters[l.String]; ok {
bigLetters = append(bigLetters, Letter{
String: val,
Style: l.Style,
RGB: l.RGB,
})
}
}
var maxHeight int
for _, l := range bigLetters {
h := strings.Count(l.String, "\n")
if h > maxHeight {
maxHeight = h
}
}
for i := 0; i <= maxHeight; i++ {
for _, letter := range bigLetters {
var letterLine string
letterLines := strings.Split(letter.String, "\n")
maxLetterWidth := internal.GetStringMaxWidth(letter.String)
if len(letterLines) > i {
letterLine = letterLines[i]
}
letterLineLength := runewidth.StringWidth(letterLine)
if letterLineLength < maxLetterWidth {
letterLine += strings.Repeat(" ", maxLetterWidth-letterLineLength)
}
if letter.RGB != (RGB{}) && (color.IsSupportRGBColor() || internal.RunsInCi()) {
ret += letter.RGB.Sprint(letterLine)
} else {
ret += letter.Style.Sprint(letterLine)
}
}
ret += "\n"
}
return ret, nil
}
// Render prints the BigText to the terminal.
func (p BigTextPrinter) Render() error {
s, _ := p.Srender()
Fprintln(p.Writer, s)
return nil
}
// DefaultBigText contains default values for BigTextPrinter.
var DefaultBigText = BigTextPrinter{
BigCharacters: map[string]string{
"a": ` █████
██ ██
███████
██ ██
██ ██ `,
"A": ` █████
██ ██
███████
██ ██
██ ██ `,
"b": `██████
██ ██
██████
██ ██
██████`,
"B": `██████
██ ██
██████
██ ██
██████`,
"c": ` ██████
██
██
██
██████`,
"C": ` ██████
██
██
██
██████`,
"d": `██████
██ ██
██ ██
██ ██
██████ `,
"D": `██████
██ ██
██ ██
██ ██
██████ `,
"e": `███████
██
█████
██
███████`,
"E": `███████
██
█████
██
███████`,
"f": `███████
██
█████
██
██ `,
"F": `███████
██
█████
██
██ `,
"g": ` ██████
██
██ ███
██ ██
██████ `,
"G": ` ██████
██
██ ███
██ ██
██████ `,
"h": `██ ██
██ ██
███████
██ ██
██ ██ `,
"H": `██ ██
██ ██
███████
██ ██
██ ██ `,
"i": `██
██
██
██
██`,
"I": `██
██
██
██
██`,
"j": ` ██
██
██
██ ██
█████ `,
"J": ` ██
██
██
██ ██
█████ `,
"k": `██ ██
██ ██
█████
██ ██
██ ██`,
"K": `██ ██
██ ██
█████
██ ██
██ ██`,
"l": `██
██
██
██
███████ `,
"L": `██
██
██
██
███████ `,
"m": `███ ███
████ ████
██ ████ ██
██ ██ ██
██ ██`,
"M": `███ ███
████ ████
██ ████ ██
██ ██ ██
██ ██`,
"n": `███ ██
████ ██
██ ██ ██
██ ██ ██
██ ████`,
"N": `███ ██
████ ██
██ ██ ██
██ ██ ██
██ ████`,
"o": ` ██████
██ ██
██ ██
██ ██
██████ `,
"O": ` ██████
██ ██
██ ██
██ ██
██████ `,
"p": `██████
██ ██
██████
██
██ `,
"P": `██████
██ ██
██████
██
██ `,
"q": ` ██████
██ ██
██ ██
██ ▄▄ ██
██████
▀▀ `,
"Q": ` ██████
██ ██
██ ██
██ ▄▄ ██
██████
▀▀ `,
"r": `██████
██ ██
██████
██ ██
██ ██`,
"R": `██████
██ ██
██████
██ ██
██ ██`,
"s": `███████
██
███████
██
███████`,
"S": `███████
██
███████
██
███████`,
"t": `████████
██
██
██
██ `,
"T": `████████
██
██
██
██ `,
"u": `██ ██
██ ██
██ ██
██ ██
██████ `,
"U": `██ ██
██ ██
██ ██
██ ██
██████ `,
"v": `██ ██
██ ██
██ ██
██ ██
████ `,
"V": `██ ██
██ ██
██ ██
██ ██
████ `,
"w": `██ ██
██ ██
██ █ ██
██ ███ ██
███ ███ `,
"W": `██ ██
██ ██
██ █ ██
██ ███ ██
███ ███ `,
"x": `██ ██
██ ██
███
██ ██
██ ██ `,
"X": `██ ██
██ ██
███
██ ██
██ ██ `,
"y": `██ ██
██ ██
████
██
██ `,
"Y": `██ ██
██ ██
████
██
██ `,
"z": `███████
███
███
███
███████`,
"Z": `███████
███
███
███
███████`,
"0": ` ██████
██ ████
██ ██ ██
████ ██
██████ `,
"1": ` ██
███
██
██
██ `,
"2": `██████
██
█████
██
███████ `,
"3": `██████
██
█████
██
██████ `,
"4": `██ ██
██ ██
███████
██
██ `,
"5": `███████
██
███████
██
███████`,
"6": ` ██████
██
███████
██ ██
██████ `,
"7": `███████
██
██
██
██`,
"8": ` █████
██ ██
█████
██ ██
█████ `,
"9": ` █████
██ ██
██████
██
█████ `,
" ": " ",
"!": `██
██
██
██ `,
"$": `▄▄███▄▄·
██
███████
██
███████
▀▀▀ `,
"%": `██ ██
██
██
██
██ ██`,
"/": ` ██
██
██
██
██ `,
"(": ` ██
██
██
██
██ `,
")": `██
██
██
██
██ `,
"?": `██████
██
▄███
▀▀
██ `,
"[": `███
██
██
██
███`,
"]": `███
██
██
██
███ `,
".": `
██`,
",": `
▄█`,
"-": `
█████
`,
"<": ` ██
██
██
██
██ `,
">": `██
██
██
██
██ `,
"*": `
▄ ██ ▄
████
▀ ██ ▀
`,
"#": ` ██ ██
████████
██ ██
████████
██ ██ `,
"_": `
███████ `,
":": `
██
██ `,
"°": ` ████
██ ██
████
`,
},
}
golang-github-pterm-pterm-0.12.79/bigtext_printer_test.go 0000664 0000000 0000000 00000007316 14650106263 0023504 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"fmt"
"os"
"strings"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBigTextPrinterNilPrint(t *testing.T) {
p := pterm.BigTextPrinter{}
p.Render()
}
func TestBigTextPrinter_Render(t *testing.T) {
printer := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString("Hello"))
content, err := printer.Srender()
testza.AssertNoError(t, err)
testza.AssertNotZero(t, content)
}
func TestBigTextPrinter_RenderRGB(t *testing.T) {
printer := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromStringWithRGB("Hello", pterm.NewRGB(255, 0, 0)))
content, err := printer.Srender()
testza.AssertNoError(t, err)
testza.AssertNotZero(t, content)
}
func TestBigTextPrinter_RenderRawOutput(t *testing.T) {
printer := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString("Hello"))
pterm.DisableStyling()
content, err := printer.Srender()
pterm.EnableStyling()
testza.AssertNoError(t, err)
testza.AssertNotZero(t, content)
}
func TestBigTextPrinter_WithBigCharacters(t *testing.T) {
e := map[string]string{"a": "b", "c": "d"}
p := pterm.BigTextPrinter{}
p2 := p.WithBigCharacters(e)
testza.AssertEqual(t, e, p2.BigCharacters)
testza.AssertZero(t, p.BigCharacters)
}
func TestBigTextPrinter_WithLetters(t *testing.T) {
e := pterm.Letters{
pterm.Letter{
String: "test",
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Letter{
String: "test2",
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}
p := pterm.BigTextPrinter{}
p2 := p.WithLetters(e)
testza.AssertEqual(t, e, p2.Letters)
testza.AssertZero(t, p.Letters)
}
func TestLetter_WithString(t *testing.T) {
e := "Hello, World!"
p := pterm.Letter{}
p2 := p.WithString(e)
testza.AssertEqual(t, e, p2.String)
testza.AssertZero(t, p.String)
}
func TestLetter_WithStyle(t *testing.T) {
p := pterm.Letter{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithStyle(s)
testza.AssertEqual(t, s, p2.Style)
testza.AssertZero(t, p.Style)
}
func TestLetter_WithRGB(t *testing.T) {
p := pterm.Letter{}
rgb := pterm.NewRGB(0, 0, 0)
p2 := p.WithRGB(rgb)
testza.AssertEqual(t, rgb, p2.RGB)
testza.AssertZero(t, p.RGB)
}
func TestNewLettersFromText(t *testing.T) {
e := pterm.Letters{
pterm.Letter{
String: "a",
Style: &pterm.ThemeDefault.LetterStyle,
},
pterm.Letter{
String: "b",
Style: &pterm.ThemeDefault.LetterStyle,
},
}
p := pterm.NewLettersFromString("ab")
testza.AssertEqual(t, e, p)
}
func TestNewLettersFromTextWithStyle(t *testing.T) {
e := pterm.Letters{
pterm.Letter{
String: "a",
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
pterm.Letter{
String: "b",
Style: pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold),
},
}
p := pterm.NewLettersFromStringWithStyle("ab", pterm.NewStyle(pterm.FgRed, pterm.BgBlue, pterm.Bold))
testza.AssertEqual(t, e, p)
}
func TestNewLettersFromTextWithRGB(t *testing.T) {
e := pterm.Letters{
pterm.Letter{
String: "a",
Style: pterm.NewStyle(),
RGB: pterm.NewRGB(0, 0, 0),
},
pterm.Letter{
String: "b",
Style: pterm.NewStyle(),
RGB: pterm.NewRGB(0, 0, 0),
},
}
p := pterm.NewLettersFromStringWithRGB("ab", pterm.NewRGB(0, 0, 0))
testza.AssertEqual(t, e, p)
}
func TestDefaultLettersMaxHeight(t *testing.T) {
maxHeight := 5
chars := pterm.DefaultBigText.BigCharacters
for s, l := range chars {
h := strings.Count(l, "\n")
testza.AssertTrue(t, h <= maxHeight, fmt.Sprintf("'%s' is too high", s))
}
}
func TestBigTextPrinter_WithWriter(t *testing.T) {
p := pterm.BigTextPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/box_printer.go 0000664 0000000 0000000 00000032362 14650106263 0021566 0 ustar 00root root 0000000 0000000 package pterm
import (
"fmt"
"io"
"strings"
"github.com/mattn/go-runewidth"
"github.com/pterm/pterm/internal"
)
// BoxPrinter is able to render a box around printables.
type BoxPrinter struct {
Title string
TitleTopLeft bool
TitleTopRight bool
TitleTopCenter bool
TitleBottomLeft bool
TitleBottomRight bool
TitleBottomCenter bool
TextStyle *Style
VerticalString string
BoxStyle *Style
HorizontalString string
TopRightCornerString string
TopLeftCornerString string
BottomLeftCornerString string
BottomRightCornerString string
TopPadding int
BottomPadding int
RightPadding int
LeftPadding int
Writer io.Writer
}
// DefaultBox is the default BoxPrinter.
var DefaultBox = BoxPrinter{
VerticalString: "|",
TopRightCornerString: "└",
TopLeftCornerString: "┘",
BottomLeftCornerString: "┐",
BottomRightCornerString: "┌",
HorizontalString: "─",
BoxStyle: &ThemeDefault.BoxStyle,
TextStyle: &ThemeDefault.BoxTextStyle,
RightPadding: 1,
LeftPadding: 1,
TopPadding: 0,
BottomPadding: 0,
TitleTopLeft: true,
}
// WithTitle returns a new box with a specific Title.
func (p BoxPrinter) WithTitle(str string) *BoxPrinter {
p.Title = str
return &p
}
// WithTitleTopLeft returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleTopLeft(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = b2
p.TitleTopRight = false
p.TitleTopCenter = false
p.TitleBottomLeft = false
p.TitleBottomRight = false
p.TitleBottomCenter = false
return &p
}
// WithTitleTopRight returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleTopRight(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = false
p.TitleTopRight = b2
p.TitleTopCenter = false
p.TitleBottomLeft = false
p.TitleBottomRight = false
p.TitleBottomCenter = false
return &p
}
// WithTitleTopCenter returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleTopCenter(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = false
p.TitleTopRight = false
p.TitleTopCenter = b2
p.TitleBottomLeft = false
p.TitleBottomRight = false
p.TitleBottomCenter = false
return &p
}
// WithTitleBottomLeft returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleBottomLeft(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = false
p.TitleTopRight = false
p.TitleTopCenter = false
p.TitleBottomLeft = b2
p.TitleBottomRight = false
p.TitleBottomCenter = false
return &p
}
// WithTitleBottomRight returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleBottomRight(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = false
p.TitleTopRight = false
p.TitleTopCenter = false
p.TitleBottomLeft = false
p.TitleBottomRight = b2
p.TitleBottomCenter = false
return &p
}
// WithTitleBottomCenter returns a new box with a specific Title alignment.
func (p BoxPrinter) WithTitleBottomCenter(b ...bool) *BoxPrinter {
b2 := internal.WithBoolean(b)
p.TitleTopLeft = false
p.TitleTopRight = false
p.TitleTopCenter = false
p.TitleBottomLeft = false
p.TitleBottomRight = false
p.TitleBottomCenter = b2
return &p
}
// WithBoxStyle returns a new box with a specific box Style.
func (p BoxPrinter) WithBoxStyle(style *Style) *BoxPrinter {
p.BoxStyle = style
return &p
}
// WithTextStyle returns a new box with a specific text Style.
func (p BoxPrinter) WithTextStyle(style *Style) *BoxPrinter {
p.TextStyle = style
return &p
}
// WithTopRightCornerString returns a new box with a specific TopRightCornerString.
func (p BoxPrinter) WithTopRightCornerString(str string) *BoxPrinter {
p.TopRightCornerString = str
return &p
}
// WithTopLeftCornerString returns a new box with a specific TopLeftCornerString.
func (p BoxPrinter) WithTopLeftCornerString(str string) *BoxPrinter {
p.TopLeftCornerString = str
return &p
}
// WithBottomRightCornerString returns a new box with a specific BottomRightCornerString.
func (p BoxPrinter) WithBottomRightCornerString(str string) *BoxPrinter {
p.BottomRightCornerString = str
return &p
}
// WithBottomLeftCornerString returns a new box with a specific BottomLeftCornerString.
func (p BoxPrinter) WithBottomLeftCornerString(str string) *BoxPrinter {
p.BottomLeftCornerString = str
return &p
}
// WithVerticalString returns a new box with a specific VerticalString.
func (p BoxPrinter) WithVerticalString(str string) *BoxPrinter {
p.VerticalString = str
return &p
}
// WithHorizontalString returns a new box with a specific HorizontalString.
func (p BoxPrinter) WithHorizontalString(str string) *BoxPrinter {
p.HorizontalString = str
return &p
}
// WithTopPadding returns a new box with a specific TopPadding.
func (p BoxPrinter) WithTopPadding(padding int) *BoxPrinter {
if padding < 0 {
padding = 0
}
p.TopPadding = padding
return &p
}
// WithBottomPadding returns a new box with a specific BottomPadding.
func (p BoxPrinter) WithBottomPadding(padding int) *BoxPrinter {
if padding < 0 {
padding = 0
}
p.BottomPadding = padding
return &p
}
// WithRightPadding returns a new box with a specific RightPadding.
func (p BoxPrinter) WithRightPadding(padding int) *BoxPrinter {
if padding < 0 {
padding = 0
}
p.RightPadding = padding
return &p
}
// WithLeftPadding returns a new box with a specific LeftPadding.
func (p BoxPrinter) WithLeftPadding(padding int) *BoxPrinter {
if padding < 0 {
padding = 0
}
p.LeftPadding = padding
return &p
}
// WithWriter sets the custom Writer.
func (p BoxPrinter) WithWriter(writer io.Writer) *BoxPrinter {
p.Writer = writer
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 BoxPrinter) Sprint(a ...interface{}) string {
if p.BoxStyle == nil {
p.BoxStyle = &ThemeDefault.BoxStyle
}
if p.TextStyle == nil {
p.TextStyle = &ThemeDefault.BoxTextStyle
}
maxWidth := internal.GetStringMaxWidth(Sprint(a...))
var topLine string
var bottomLine string
if p.Title == "" {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else {
p.Title = strings.ReplaceAll(p.Title, "\n", " ")
if (maxWidth + p.RightPadding + p.LeftPadding - 4) < internal.GetStringMaxWidth(p.Title) {
p.RightPadding = internal.GetStringMaxWidth(p.Title) - (maxWidth + p.RightPadding + p.LeftPadding - 5)
}
if p.TitleTopLeft {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + internal.AddTitleToLine(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding, true) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else if p.TitleTopRight {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + internal.AddTitleToLine(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding, false) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else if p.TitleTopCenter {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + internal.AddTitleToLineCenter(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else if p.TitleBottomLeft {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + internal.AddTitleToLine(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding, true) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else if p.TitleBottomRight {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + internal.AddTitleToLine(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding, false) + p.BoxStyle.Sprint(p.TopLeftCornerString)
} else if p.TitleBottomCenter {
topLine = p.BoxStyle.Sprint(p.BottomRightCornerString) + strings.Repeat(p.BoxStyle.Sprint(p.HorizontalString),
maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.BottomLeftCornerString)
bottomLine = p.BoxStyle.Sprint(p.TopRightCornerString) + internal.AddTitleToLineCenter(p.Title, p.BoxStyle.Sprint(p.HorizontalString), maxWidth+p.LeftPadding+p.RightPadding) + p.BoxStyle.Sprint(p.TopLeftCornerString)
}
}
boxString := strings.Repeat("\n", p.TopPadding) + Sprint(a...) + strings.Repeat("\n", p.BottomPadding)
ss := strings.Split(boxString, "\n")
for i, s2 := range ss {
if runewidth.StringWidth(RemoveColorFromString(s2)) < maxWidth {
ss[i] = p.BoxStyle.Sprint(p.VerticalString) + strings.Repeat(" ", p.LeftPadding) + p.TextStyle.Sprint(s2) +
strings.Repeat(" ", maxWidth-runewidth.StringWidth(RemoveColorFromString(s2))+p.RightPadding) +
p.BoxStyle.Sprint(p.VerticalString)
} else {
ss[i] = p.BoxStyle.Sprint(p.VerticalString) + strings.Repeat(" ", p.LeftPadding) + p.TextStyle.Sprint(s2) +
strings.Repeat(" ", p.RightPadding) + p.BoxStyle.Sprint(p.VerticalString)
}
}
return topLine + "\n" + strings.Join(ss, "\n") + "\n" + bottomLine
}
// 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 BoxPrinter) Sprintln(a ...interface{}) string {
return p.Sprint(strings.TrimSuffix(Sprintln(a...), "\n")) + "\n"
}
// Sprintf formats according to a format specifier and returns the resulting string.
func (p BoxPrinter) 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 BoxPrinter) 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 BoxPrinter) Print(a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 BoxPrinter) Println(a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 BoxPrinter) Printf(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 BoxPrinter) Printfln(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 BoxPrinter) 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 BoxPrinter) 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
}
golang-github-pterm-pterm-0.12.79/box_printer_test.go 0000664 0000000 0000000 00000020774 14650106263 0022631 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"errors"
"io"
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBoxPrinterNilPrint(t *testing.T) {
p := pterm.BoxPrinter{}
p.Println("Hello, World!")
}
func TestBoxPrinterPrintMethods(t *testing.T) {
p := pterm.DefaultBox
t.Run("Print", func(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
p.Print(a)
})
})
t.Run("Printf", func(t *testing.T) {
testPrintfContains(t, func(w io.Writer, format string, a interface{}) {
p.Printf(format, a)
})
})
t.Run("Printfln", func(t *testing.T) {
testPrintflnContains(t, func(w io.Writer, format string, a interface{}) {
p.Printfln(format, a)
})
})
t.Run("Println", func(t *testing.T) {
testPrintlnContains(t, func(w io.Writer, a interface{}) {
p.Println(a)
})
})
t.Run("Sprint", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint(a)
})
})
t.Run("SprintWithTitle", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.WithTitle("a").Sprint(a)
})
})
t.Run("Sprintf", func(t *testing.T) {
testSprintfContains(t, func(format string, a interface{}) string {
return p.Sprintf(format, a)
})
})
t.Run("Sprintfln", func(t *testing.T) {
testSprintflnContains(t, func(format string, a interface{}) string {
return p.Sprintfln(format, a)
})
})
t.Run("Sprintln", func(t *testing.T) {
testSprintlnContains(t, func(a interface{}) string {
return p.Sprintln(a)
})
})
t.Run("SprintMultipleLines", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint("testing\ntesting2" + pterm.Sprint(a))
})
})
t.Run("PrintOnError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(nil)
})
testza.AssertZero(t, result)
})
t.Run("PrintOnErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("wrapping error : %w", errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("", nil)
})
testza.AssertZero(t, result)
})
}
func TestBoxPrinter_WithBottomLeftCornerString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithBottomLeftCornerString("-")
testza.AssertEqual(t, "-", p2.BottomLeftCornerString)
testza.AssertZero(t, p.BottomLeftCornerString)
}
func TestBoxPrinter_WithBottomPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithBottomPadding(5)
testza.AssertEqual(t, 5, p2.BottomPadding)
testza.AssertZero(t, p.BottomPadding)
}
func TestBoxPrinter_WithBottomRightCornerString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithBottomRightCornerString("-")
testza.AssertEqual(t, "-", p2.BottomRightCornerString)
testza.AssertZero(t, p.BottomRightCornerString)
}
func TestBoxPrinter_WithTitle(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitle("-")
testza.AssertEqual(t, "-", p2.Title)
testza.AssertZero(t, p.Title)
}
func TestBoxPrinter_WithTitleTopLeft(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopLeft()
testza.AssertEqual(t, true, p2.TitleTopLeft)
testza.AssertEqual(t, false, p.TitleTopLeft)
}
func TestBoxPrinter_WithTitleTopRight(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopRight()
testza.AssertEqual(t, true, p2.TitleTopRight)
testza.AssertEqual(t, false, p.TitleTopRight)
}
func TestBoxPrinter_WithTitleTopCenter(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopCenter()
testza.AssertEqual(t, true, p2.TitleTopCenter)
testza.AssertEqual(t, false, p.TitleTopCenter)
}
func TestBoxPrinter_WithTitleBottomRight(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomRight()
testza.AssertEqual(t, true, p2.TitleBottomRight)
testza.AssertEqual(t, false, p.TitleBottomRight)
}
func TestBoxPrinter_WithTitleBottomLeft(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomLeft()
testza.AssertEqual(t, true, p2.TitleBottomLeft)
testza.AssertEqual(t, false, p.TitleBottomLeft)
}
func TestBoxPrinter_WithTitleBottomCenter(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomCenter()
testza.AssertEqual(t, true, p2.TitleBottomCenter)
testza.AssertEqual(t, false, p.TitleBottomCenter)
}
func TestBoxPrinter_WithTitleWithTitleBottomLeft(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomLeft().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithTitleWithTitleTopLeft(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopLeft().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithTitleWithTitleBottomRight(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomRight().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithTitleWithTitleTopRight(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopRight().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithTitleWithTitleTopCenter(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleTopCenter().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithTitleWithTitleBottomCenter(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTitleBottomCenter().WithTitle("a").Sprint("Lorem Ipsum")
testza.AssertContains(t, p2, "Lorem Ipsum")
}
func TestBoxPrinter_WithBoxStyle(t *testing.T) {
p := pterm.BoxPrinter{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithBoxStyle(s)
testza.AssertEqual(t, s, p2.BoxStyle)
testza.AssertZero(t, p.BoxStyle)
}
func TestBoxPrinter_WithLeftPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithLeftPadding(5)
testza.AssertEqual(t, 5, p2.LeftPadding)
testza.AssertZero(t, p.LeftPadding)
}
func TestBoxPrinter_WithRightPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithRightPadding(5)
testza.AssertEqual(t, 5, p2.RightPadding)
testza.AssertZero(t, p.RightPadding)
}
func TestBoxPrinter_WithTextStyle(t *testing.T) {
p := pterm.BoxPrinter{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithTextStyle(s)
testza.AssertEqual(t, s, p2.TextStyle)
testza.AssertZero(t, p.TextStyle)
}
func TestBoxPrinter_WithTopLeftCornerString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTopLeftCornerString("-")
testza.AssertEqual(t, "-", p2.TopLeftCornerString)
testza.AssertZero(t, p.TopLeftCornerString)
}
func TestBoxPrinter_WithTopPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTopPadding(5)
testza.AssertEqual(t, 5, p2.TopPadding)
testza.AssertZero(t, p.TopPadding)
}
func TestBoxPrinter_WithInvalidTopPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTopPadding(-5)
testza.AssertEqual(t, 0, p2.TopPadding)
testza.AssertZero(t, p.TopPadding)
}
func TestBoxPrinter_WithInvalidBottomPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithBottomPadding(-5)
testza.AssertEqual(t, 0, p2.BottomPadding)
testza.AssertZero(t, p.BottomPadding)
}
func TestBoxPrinter_WithInvalidLeftPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithLeftPadding(-5)
testza.AssertEqual(t, 0, p2.LeftPadding)
testza.AssertZero(t, p.LeftPadding)
}
func TestBoxPrinter_WithInvalidRightPadding(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithRightPadding(-5)
testza.AssertEqual(t, 0, p2.RightPadding)
testza.AssertZero(t, p.RightPadding)
}
func TestBoxPrinter_WithTopRightCornerString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithTopRightCornerString("-")
testza.AssertEqual(t, "-", p2.TopRightCornerString)
testza.AssertZero(t, p.TopRightCornerString)
}
func TestBoxPrinter_WithVerticalString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithVerticalString("-")
testza.AssertEqual(t, "-", p2.VerticalString)
testza.AssertZero(t, p.VerticalString)
}
func TestBoxPrinter_WithHorizontalString(t *testing.T) {
p := pterm.BoxPrinter{}
p2 := p.WithHorizontalString("-")
testza.AssertEqual(t, "-", p2.HorizontalString)
testza.AssertZero(t, p.HorizontalString)
}
func TestBoxPrinter_WithWriter(t *testing.T) {
p := pterm.BoxPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/bulletlist_printer.go 0000664 0000000 0000000 00000006752 14650106263 0023165 0 ustar 00root root 0000000 0000000 package pterm
import (
"io"
"strings"
)
// BulletListItem is able to render a ListItem.
type BulletListItem struct {
Level int
Text string
TextStyle *Style
Bullet string
BulletStyle *Style
}
// WithLevel returns a new BulletListItem with a specific Level.
func (p BulletListItem) WithLevel(level int) *BulletListItem {
p.Level = level
return &p
}
// WithText returns a new BulletListItem with a specific Text.
func (p BulletListItem) WithText(text string) *BulletListItem {
p.Text = text
return &p
}
// WithTextStyle returns a new BulletListItem with a specific TextStyle.
func (p BulletListItem) WithTextStyle(style *Style) *BulletListItem {
p.TextStyle = style
return &p
}
// WithBullet returns a new BulletListItem with a specific Prefix.
func (p BulletListItem) WithBullet(bullet string) *BulletListItem {
p.Bullet = bullet
return &p
}
// WithBulletStyle returns a new BulletListItem with a specific BulletStyle.
func (p BulletListItem) WithBulletStyle(style *Style) *BulletListItem {
p.BulletStyle = style
return &p
}
// DefaultBulletList contains standards, which can be used to print a BulletListPrinter.
var DefaultBulletList = BulletListPrinter{
Bullet: "•",
TextStyle: &ThemeDefault.BulletListTextStyle,
BulletStyle: &ThemeDefault.BulletListBulletStyle,
}
// BulletListPrinter is able to render a list.
type BulletListPrinter struct {
Items []BulletListItem
TextStyle *Style
Bullet string
BulletStyle *Style
Writer io.Writer
}
// WithItems returns a new list with specific Items.
func (l BulletListPrinter) WithItems(items []BulletListItem) *BulletListPrinter {
l.Items = append(l.Items, items...)
return &l
}
// WithTextStyle returns a new list with a specific text style.
func (l BulletListPrinter) WithTextStyle(style *Style) *BulletListPrinter {
l.TextStyle = style
return &l
}
// WithBullet returns a new list with a specific bullet.
func (l BulletListPrinter) WithBullet(bullet string) *BulletListPrinter {
l.Bullet = bullet
return &l
}
// WithBulletStyle returns a new list with a specific bullet style.
func (l BulletListPrinter) WithBulletStyle(style *Style) *BulletListPrinter {
l.BulletStyle = style
return &l
}
// WithWriter sets the custom Writer.
func (l BulletListPrinter) WithWriter(writer io.Writer) *BulletListPrinter {
l.Writer = writer
return &l
}
// Render prints the list to the terminal.
func (l BulletListPrinter) Render() error {
s, _ := l.Srender()
Fprintln(l.Writer, s)
return nil
}
// Srender renders the list as a string.
func (l BulletListPrinter) Srender() (string, error) {
var ret string
for _, item := range l.Items {
if item.TextStyle == nil {
if l.TextStyle == nil {
item.TextStyle = &ThemeDefault.BulletListTextStyle
} else {
item.TextStyle = l.TextStyle
}
}
if item.BulletStyle == nil {
if l.BulletStyle == nil {
item.BulletStyle = &ThemeDefault.BulletListBulletStyle
} else {
item.BulletStyle = l.BulletStyle
}
}
split := strings.Split(item.Text, "\n")
for i, line := range split {
if i == 0 {
if item.Bullet == "" {
ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(l.Bullet) + " " + item.TextStyle.Sprint(line) + "\n"
} else {
ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(item.Bullet) + " " + item.TextStyle.Sprint(line) + "\n"
}
} else {
ret += strings.Repeat(" ", item.Level) + strings.Repeat(" ", len(item.Bullet)) + " " + item.TextStyle.Sprint(line) + "\n"
}
}
}
return ret, nil
}
golang-github-pterm-pterm-0.12.79/bulletlist_printer_test.go 0000664 0000000 0000000 00000007365 14650106263 0024225 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"fmt"
"io"
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestBulletListPrinterNilPrint(t *testing.T) {
p := pterm.BulletListPrinter{}
p.Render()
}
func TestBulletListPrinter_Render(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
{Level: 0, Text: fmt.Sprint(a)},
}).Render()
})
}
func TestBulletListPrinter_RenderWithoutStyle(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
pterm.BulletListPrinter{}.WithItems([]pterm.BulletListItem{
{Level: 0, Text: fmt.Sprint(a)},
}).Render()
})
}
func TestBulletListPrinter_RenderWithBullet(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
{
Level: 0,
Text: fmt.Sprint(a),
Bullet: "-",
},
}).Render()
})
}
func TestBulletListPrinter_Srender(t *testing.T) {
testSprintContainsWithoutError(t, func(a interface{}) (string, error) {
return pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
{Level: 0, Text: fmt.Sprint(a)},
}).Srender()
})
}
func TestBulletListPrinter_WithBullet(t *testing.T) {
p := pterm.BulletListPrinter{}
p2 := p.WithBullet("-")
testza.AssertEqual(t, "-", p2.Bullet)
testza.AssertZero(t, p.Bullet)
}
func TestBulletListPrinter_WithBulletStyle(t *testing.T) {
p := pterm.BulletListPrinter{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithBulletStyle(s)
testza.AssertEqual(t, s, p2.BulletStyle)
testza.AssertZero(t, p.BulletStyle)
}
func TestBulletListPrinter_WithItems(t *testing.T) {
p := pterm.BulletListPrinter{}
li := []pterm.BulletListItem{{
Level: 0,
Text: "test",
TextStyle: nil,
Bullet: "+",
BulletStyle: nil,
}}
p2 := p.WithItems(li)
testza.AssertEqual(t, li, p2.Items)
testza.AssertZero(t, p.Items)
}
func TestBulletListPrinter_WithTextStyle(t *testing.T) {
p := pterm.BulletListPrinter{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithTextStyle(s)
testza.AssertEqual(t, s, p2.TextStyle)
testza.AssertZero(t, p.TextStyle)
}
func TestBulletListItem_WithBullet(t *testing.T) {
p := pterm.BulletListItem{}
p2 := p.WithBullet("-")
testza.AssertEqual(t, "-", p2.Bullet)
testza.AssertZero(t, p.Bullet)
}
func TestBulletListItem_WithBulletStyle(t *testing.T) {
p := pterm.BulletListItem{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithBulletStyle(s)
testza.AssertEqual(t, s, p2.BulletStyle)
testza.AssertZero(t, p.BulletStyle)
}
func TestBulletListItem_WithLevel(t *testing.T) {
p := pterm.BulletListItem{}
p2 := p.WithLevel(1)
testza.AssertEqual(t, 1, p2.Level)
testza.AssertZero(t, p.Level)
}
func TestBulletListItem_WithText(t *testing.T) {
p := pterm.BulletListItem{}
p2 := p.WithText("test")
testza.AssertEqual(t, "test", p2.Text)
testza.AssertZero(t, p.Text)
}
func TestBulletListItem_WithTextStyle(t *testing.T) {
p := pterm.BulletListItem{}
s := pterm.NewStyle(pterm.FgRed, pterm.BgRed, pterm.Bold)
p2 := p.WithTextStyle(s)
testza.AssertEqual(t, s, p2.TextStyle)
testza.AssertZero(t, p.TextStyle)
}
func TestNewBulletListFromString(t *testing.T) {
p := *pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
{Level: 0, Text: "0"},
{Level: 1, Text: "1"},
{Level: 2, Text: "2"},
{Level: 3, Text: "3"},
{Level: 4, Text: "4"},
{Level: 5, Text: "5"},
})
s := `0
1
2
3
4
5`
p2 := pterm.NewBulletListFromString(s, " ")
testza.AssertEqual(t, p, p2)
}
func TestBulletListPrinter_WithWriter(t *testing.T) {
p := pterm.BulletListPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/center_printer.go 0000664 0000000 0000000 00000011205 14650106263 0022247 0 ustar 00root root 0000000 0000000 package pterm
import (
"fmt"
"io"
"strings"
"github.com/mattn/go-runewidth"
"github.com/pterm/pterm/internal"
)
// DefaultCenter is the default CenterPrinter.
var DefaultCenter = CenterPrinter{
CenterEachLineSeparately: false,
}
// CenterPrinter prints centered text.
type CenterPrinter struct {
CenterEachLineSeparately bool
Writer io.Writer
}
// WithCenterEachLineSeparately centers each line separately.
func (p CenterPrinter) WithCenterEachLineSeparately(b ...bool) *CenterPrinter {
bt := internal.WithBoolean(b)
p.CenterEachLineSeparately = bt
return &p
}
// WithWriter sets the custom Writer.
func (p CenterPrinter) WithWriter(writer io.Writer) *CenterPrinter {
p.Writer = writer
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 CenterPrinter) Sprint(a ...interface{}) string {
if RawOutput {
return Sprint(a...)
}
lines := strings.Split(Sprint(a...), "\n")
var ret string
if p.CenterEachLineSeparately {
for _, line := range lines {
margin := (GetTerminalWidth() - runewidth.StringWidth(RemoveColorFromString(line))) / 2
if margin < 1 {
ret += line + "\n"
} else {
ret += strings.Repeat(" ", margin) + line + "\n"
}
}
return ret
}
var maxLineWidth int
for _, line := range lines {
lineLength := runewidth.StringWidth(RemoveColorFromString(line))
if maxLineWidth < lineLength {
maxLineWidth = lineLength
}
}
indent := GetTerminalWidth() - maxLineWidth
if indent/2 < 1 {
for _, line := range lines {
ret += line + "\n"
}
return ret
}
for _, line := range lines {
ret += strings.Repeat(" ", indent/2) + line + "\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 CenterPrinter) Sprintln(a ...interface{}) string {
return p.Sprint(Sprintln(a...))
}
// Sprintf formats according to a format specifier and returns the resulting string.
func (p CenterPrinter) 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 CenterPrinter) 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 CenterPrinter) Print(a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 CenterPrinter) Println(a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 CenterPrinter) Printf(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 CenterPrinter) Printfln(format string, a ...interface{}) *TextPrinter {
Fprint(p.Writer, 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 CenterPrinter) 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 CenterPrinter) 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
}
golang-github-pterm-pterm-0.12.79/center_printer_test.go 0000664 0000000 0000000 00000007713 14650106263 0023317 0 ustar 00root root 0000000 0000000 package pterm_test
import (
"errors"
"io"
"os"
"testing"
"github.com/MarvinJWendt/testza"
"github.com/pterm/pterm"
)
func TestCenterPrinter_WithCenterEachLineSeparately(t *testing.T) {
p := pterm.CenterPrinter{}
p2 := p.WithCenterEachLineSeparately()
testza.AssertTrue(t, p2.CenterEachLineSeparately)
testza.AssertFalse(t, p.CenterEachLineSeparately)
}
func TestCenterPrinterPrintMethods(t *testing.T) {
p := pterm.DefaultCenter
t.Run("Print", func(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
p.Print(a)
})
})
t.Run("Printf", func(t *testing.T) {
testPrintfContains(t, func(w io.Writer, format string, a interface{}) {
p.Printf(format, a)
})
})
t.Run("Printfln", func(t *testing.T) {
testPrintflnContains(t, func(w io.Writer, format string, a interface{}) {
p.Printfln(format, a)
})
})
t.Run("Println", func(t *testing.T) {
testPrintlnContains(t, func(w io.Writer, a interface{}) {
p.Println(a)
})
})
t.Run("Sprint", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint(a)
})
})
t.Run("Sprintf", func(t *testing.T) {
testSprintfContains(t, func(format string, a interface{}) string {
return p.Sprintf(format, a)
})
})
t.Run("Sprintfln", func(t *testing.T) {
testSprintflnContains(t, func(format string, a interface{}) string {
return p.Sprintfln(format, a)
})
})
t.Run("Sprintln", func(t *testing.T) {
testSprintlnContains(t, func(a interface{}) string {
return p.Sprintln(a)
})
})
t.Run("PrintOnError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutError", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnError(nil)
})
testza.AssertZero(t, result)
})
t.Run("PrintOnErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("wrapping error : %w", errors.New("hello world"))
})
testza.AssertContains(t, result, "hello world")
})
t.Run("PrintIfError_WithoutErrorf", func(t *testing.T) {
result := captureStdout(func(w io.Writer) {
p.PrintOnErrorf("", nil)
})
testza.AssertZero(t, result)
})
}
func TestCenterPrinterPrintMethodsCenterSeparately(t *testing.T) {
p := pterm.DefaultCenter.WithCenterEachLineSeparately()
t.Run("Print", func(t *testing.T) {
testPrintContains(t, func(w io.Writer, a interface{}) {
p.Print(a)
})
})
t.Run("Printf", func(t *testing.T) {
testPrintfContains(t, func(w io.Writer, format string, a interface{}) {
p.Printf(format, a)
})
})
t.Run("Println", func(t *testing.T) {
testPrintlnContains(t, func(w io.Writer, a interface{}) {
p.Println(a)
})
})
t.Run("Sprint", func(t *testing.T) {
testSprintContains(t, func(a interface{}) string {
return p.Sprint(a)
})
})
t.Run("Sprintf", func(t *testing.T) {
testSprintfContains(t, func(format string, a interface{}) string {
return p.Sprintf(format, a)
})
})
t.Run("Sprintln", func(t *testing.T) {
testSprintlnContains(t, func(a interface{}) string {
return p.Sprintln(a)
})
})
}
func TestCenterPrinter_SprintLineLongerThanTerminal(t *testing.T) {
p := pterm.DefaultCenter
p2 := p.Sprint("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
testza.AssertContains(t, p2, "a")
}
func TestCenterPrinter_SprintLineLongerThanTerminalWithCenterEachLineSeparately(t *testing.T) {
p := pterm.DefaultCenter
p2 := p.WithCenterEachLineSeparately().Sprint("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
testza.AssertContains(t, p2, "a")
}
func TestCenterPrinter_WithWriter(t *testing.T) {
p := pterm.CenterPrinter{}
s := os.Stderr
p2 := p.WithWriter(s)
testza.AssertEqual(t, s, p2.Writer)
testza.AssertZero(t, p.Writer)
}
golang-github-pterm-pterm-0.12.79/ci/ 0000775 0000000 0000000 00000000000 14650106263 0017271 5 ustar 00root root 0000000 0000000 golang-github-pterm-pterm-0.12.79/ci/main.go 0000664 0000000 0000000 00000031275 14650106263 0020554 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"log"
"os"
"os/exec"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/pterm/pterm"
)
type Example struct {
name string
content string
}
type Examples struct {
mu sync.Mutex
examples []Example
}
func (e *Examples) Add(name, content string) {
e.mu.Lock()
defer e.mu.Unlock()
e.examples = append(e.examples, Example{
name: name,
content: content,
})
}
func (e *Examples) GetSorted() []Example {
e.mu.Lock()
defer e.mu.Unlock()
sort.Slice(e.examples, func(i, j int) bool {
return e.examples[i].name < e.examples[j].name
})
return e.examples
}
func (e *Examples) String() string {
var output string
for _, example := range e.GetSorted() {
output += example.content
}
return output
}
func main() {
pterm.Info.Prefix = pterm.Prefix{
Text: "LOG",
Style: pterm.NewStyle(pterm.FgGray),
}
pterm.Info.MessageStyle = pterm.NewStyle(pterm.FgDefault)
do("Running PTerm CI System", 1, func(currentLevel int) {
do("Generating PUtils Docs", currentLevel, func(currentLevel int) {
pterm.Info.Println("Getting docs from 'go doc'...")
goDocOutputBytes, err := exec.Command("go", "doc", "-all", "./putils").Output()
if err != nil {
log.Panic(err)
}
goDocOutput := string(goDocOutputBytes)
goDocOutput = strings.Join(strings.Split(goDocOutput, "FUNCTIONS")[1:], "")
goDocOutputLines := strings.Split(goDocOutput, "\n")
pterm.Info.Println("Parsing docs...")
var goDocOutputFiltered []string
for _, line := range goDocOutputLines {
if strings.HasPrefix(line, "func") {
goDocOutputFiltered = append(goDocOutputFiltered, line)
}
}
pterm.Info.Println("Reading README Template")
putilsTemplateBytes, err := os.ReadFile("./putils/README.template.md")
if err != nil {
log.Panic(err)
}
pterm.Info.Println("Generating README.md")
putilsReadme := string(putilsTemplateBytes)
putilsReadme += "\n## Util Functions\n\n"
putilsReadme += fmt.Sprintf("```go\n%s\n```\n", strings.Join(goDocOutputFiltered, "\n"))
pterm.Info.Println("Writing './putils/README.md'")
os.WriteFile("./putils/README.md", []byte(putilsReadme), 0600)
pterm.Info.Println("Writing './docs/docs/putils.md'")
os.WriteFile("./docs/docs/putils.md", []byte(putilsReadme), 0600)
})
var allPrinters []string
do("Geneating printers Table", currentLevel, func(currentLevel int) {
// get features located in "_examples/*"
dirs, _ := os.ReadDir("./_examples/")
for _, dir := range dirs {
if dir.Name() == "README.md" {
continue
}
// Exclude demo folder
if dir.Name() == "demo" {
continue
}
allPrinters = append(allPrinters, dir.Name())
}
// generate table
tableContent := "| Feature | Feature | Feature | Feature | Feature |\n| :-------: | :-------: | :-------: | :-------: | :-------: |\n"
for i, feature := range allPrinters {
// the table should contain 5 columns. Each cell is a feature.
// Make multiple rows, if there are more than 4 features.
// A link to the examples should be included in every cell.
// Format: "[Example](https://github.com/pterm/pterm/tree/master/_examples/FEATURE)"
if i%5 == 0 {
tableContent += "| "
}
name := strings.ToUpper(string(feature[0])) + feature[1:]
name = strings.ReplaceAll(name, "_", " ")
tableContent += fmt.Sprintf("%s [(Examples)](https://github.com/pterm/pterm/tree/master/_examples/%s) |", name, feature)
if (i+1)%5 == 0 {
tableContent += "\n"
}
// fill left over cells with empty strings if in the last row
if i == len(allPrinters)-1 {
tableContent += strings.Repeat(" | ", 5-(i+1)%5)
}
}
// read readme
readme, _ := os.ReadFile("./README.md")
// replace table in readme
readmeString := string(readme)
readmeString = writeBetween("printers", readmeString, "\n"+tableContent+"\n")
// write readme
os.WriteFile("./README.md", []byte(readmeString), 0600)
})
do("Write printers to website", currentLevel, func(currentLevel int) {
pterm.Info.Println("Writing printers to website")
websiteIndex, _ := os.ReadFile("./docs/index.html")
websiteIndexString := string(websiteIndex)
// Write as li elements, which contain a link to the example. (https://github.com/pterm/pterm/tree/master/_examples/{name})
var links []string
for _, printer := range allPrinters {
links = append(links, fmt.Sprintf(`
---
`)
newReadmeContent = writeBetween("unittestcount2", newReadmeContent, "**`"+res+"`**")
case <-time.After(time.Second * 10):
pterm.Info.Println("!!! Timeout in counting unit tests")
}
newReadmeContent = writeBetween("examples", newReadmeContent, "\n"+readmeExamples+"\n")
})
do("Writing README", currentLevel, func(currentLevel int) {
pterm.Info.Println("Appending examples to root README.md")
pterm.Info.Println("Writing README")
err = os.WriteFile("./README.md", []byte(newReadmeContent), 0600)
if err != nil {
log.Panic(err)
}
})
})
}
func generateSectionContent(section os.DirEntry) string {
var sectionExamples string
examples, _ := os.ReadDir("./_examples/" + section.Name())
var exampleMap sync.Map
var wg sync.WaitGroup
for _, example := range examples {
if example.Name() == "README.md" {
continue
}
wg.Add(1)
go func(section os.DirEntry, example os.DirEntry) {
defer wg.Done()
dir := section.Name() + "/" + example.Name()
content := generateExampleContent(dir, section, example)
pterm.Info.Println("Storing to map: " + section.Name() + "/" + example.Name() + "...")
exampleMap.Store(example.Name(), content)
pterm.Info.Println("Stored to map: " + section.Name() + "/" + example.Name())
}(section, example)
}
wg.Wait()
var keys []string
exampleMap.Range(func(key, value interface{}) bool {
keys = append(keys, key.(string))
return true
})
sort.Slice(keys, func(i, j int) bool {
if keys[i] == "demo" {
return true
}
if keys[j] == "demo" {
return false
}
return keys[i] < keys[j]
})
for _, key := range keys {
value, _ := exampleMap.Load(key)
sectionExamples += value.(string)
}
os.WriteFile("./_examples/"+section.Name()+"/README.md", []byte(sectionExamples), 0600)
return sectionExamples
}
func generateExampleContent(dir string, section os.DirEntry, example os.DirEntry) string {
var content string
exampleRenderStart := time.Now()
animationDataPath := "./_examples/" + dir + "/animation_data.json"
animationSvgPath := "./_examples/" + dir + "/animation.svg"
exampleCode, err := os.ReadFile("./_examples/" + dir + "/main.go")
if err != nil {
log.Panic(err)
}
if fileExists(animationDataPath) {
pterm.Info.Println("[" + dir + "] 'animation_data.json' already exists. Removing it.")
err = os.Remove(animationDataPath)
if err != nil {
log.Panic(err)
}
}
if fileExists(animationSvgPath) {
pterm.Info.Println("[" + dir + "] 'animation.svg' already exists. Removing it.")
err := os.Remove(animationSvgPath)
if err != nil {
log.Panic(err)
}
}
pterm.Info.Println("[" + dir + "] Running asciinema")
execute(`go build -o ./_examples/` + dir + `/bundle ./_examples/` + dir)
execute(`asciinema rec ` + animationDataPath + ` -c "./_examples/` + dir + `/bundle && sleep 1"`)
os.Remove("./_examples/" + dir + "/bundle")
pterm.Info.Println("[" + dir + "] Adding sleep to end of 'animation_data.json'")
addSleepToEndOfAnimationData(dir, animationDataPath)
pterm.Info.Println("[" + dir + "] Generating SVG")
generateSVG(animationDataPath, animationSvgPath)
pterm.Info.Println("[" + dir + "] Overwriting SVG font")
overwriteSVGFont(dir, animationSvgPath)
pterm.Info.Println("[" + dir + "] Generating README")
readmeString := generateExampleReadme(dir, exampleCode)
err = os.WriteFile("./_examples/"+dir+"/README.md", []byte(readmeString), 0600)
if err != nil {
log.Panic(err)
}
pterm.Info.Println("[" + dir + "] Cleaning files")
os.Remove(animationDataPath)
content += "### " + section.Name() + "/" + example.Name() + "\n\n"
content += "![Animation](https://raw.githubusercontent.com/pterm/pterm/master/_examples/" + section.Name() + "/" + example.Name() + "/animation.svg)\n\n"
content += "