Repository: pterm/pterm (go)

Issue:
Rename every printer to have `Printer` as suffix
This change makes PTerm more understandable and brings all printer names to the same style.
From now on, the convention is that every printer must end with 'Printer'.

- [x] Rename every printer
- [x] Rename very test
- [x] Rename every occurrence in comments
- [x] Check **every** example

@floaust please check those checkboxes before marking your pull request as ready.

Pull request description:
refactor: make all printer names end with `Printer`
BREAKING CHANGE: change `XXX` to `XXXPrinter` to unify the naming scheme.

### Description
Changed `XXX` to `XXXPrinter` to unify the naming scheme.
Changed: 
- `Spinner`
- `Progressbar`
- `Tree`
- `Bulletlist`
- `Table`

### Scope
> What is affected by this pull request?

- [ ] Bug Fix
- [ ] New Feature
- [x] Documentation
- [x] Other

### Related Issue
Fixes #133 


### To-Do Checklist
- [x] I tested my changes
- [x] I have commented every method that I created/changed
- [x] I updated the examples to fit with my changes


Patch:
diff --git a/_examples/tree/main.go b/_examples/tree/main.go
index 8ba384b1..b6dbf894 100644
--- a/_examples/tree/main.go
+++ b/_examples/tree/main.go
@@ -34,6 +34,6 @@ func main() {
 	// Generate tree from LeveledList.
 	root := pterm.NewTreeFromLeveledList(leveledList)
 
-	// Render Tree
+	// Render TreePrinter
 	pterm.DefaultTree.WithRoot(root).Render()
 }
diff --git a/bulletlist_printer.go b/bulletlist_printer.go
index 95161b2a..764cbb31 100644
--- a/bulletlist_printer.go
+++ b/bulletlist_printer.go
@@ -6,8 +6,8 @@ import (
 	"github.com/pterm/pterm/internal"
 )
 
-// NewBulletListFromStrings returns a BulletList with Text using the NewTreeListItemFromString method.
-func NewBulletListFromStrings(s []string, padding string) BulletList {
+// NewBulletListFromStrings returns a BulletListPrinter with Text using the NewTreeListItemFromString method.
+func NewBulletListFromStrings(s []string, padding string) BulletListPrinter {
 	var lis []BulletListItem
 	for _, line := range s {
 		lis = append(lis, NewBulletListItemFromString(line, padding))
@@ -41,65 +41,49 @@ type BulletListItem struct {
 }
 
 // WithLevel returns a new BulletListItem with a specific Level.
-func (p BulletListItem) WithLevel(level int) BulletListItem {
+func (p BulletListItem) WithLevel(level int) *BulletListItem {
 	p.Level = level
-	return p
+	return &p
 }
 
 // WithText returns a new BulletListItem with a specific Text.
-func (p BulletListItem) WithText(text string) BulletListItem {
+func (p BulletListItem) WithText(text string) *BulletListItem {
 	p.Text = text
-	return p
+	return &p
 }
 
 // WithTextStyle returns a new BulletListItem with a specific TextStyle.
-func (p BulletListItem) WithTextStyle(style *Style) BulletListItem {
+func (p BulletListItem) WithTextStyle(style *Style) *BulletListItem {
 	p.TextStyle = style
-	return p
+	return &p
 }
 
 // WithBullet returns a new BulletListItem with a specific Prefix.
-func (p BulletListItem) WithBullet(bullet string) BulletListItem {
+func (p BulletListItem) WithBullet(bullet string) *BulletListItem {
 	p.Bullet = bullet
-	return p
+	return &p
 }
 
 // WithBulletStyle returns a new BulletListItem with a specific BulletStyle.
-func (p BulletListItem) WithBulletStyle(style *Style) BulletListItem {
+func (p BulletListItem) WithBulletStyle(style *Style) *BulletListItem {
 	p.BulletStyle = style
-	return p
+	return &p
 }
 
-// Render renders the BulletListItem as a string.
-func (p BulletListItem) Render() {
-	Println(p.Srender())
-}
-
-// Srender renders the BulletListItem as a string.
-func (p BulletListItem) Srender() string {
-	if p.TextStyle == nil {
-		p.TextStyle = NewStyle()
-	}
-	if p.BulletStyle == nil {
-		p.BulletStyle = &ThemeDefault.BulletListBulletStyle
-	}
-	return strings.Repeat(" ", p.Level) + p.BulletStyle.Sprint(p.Bullet) + " " + p.TextStyle.Sprint(p.Text)
-}
-
-// NewBulletListFromString returns a BulletList with Text using the NewTreeListItemFromString method, splitting after return (\n).
-func NewBulletListFromString(s string, padding string) BulletList {
+// NewBulletListFromString returns a BulletListPrinter with Text using the NewTreeListItemFromString method, splitting after return (\n).
+func NewBulletListFromString(s string, padding string) BulletListPrinter {
 	return NewBulletListFromStrings(strings.Split(s, "\n"), padding)
 }
 
-// DefaultBulletList contains standards, which can be used to print a BulletList.
-var DefaultBulletList = BulletList{
+// DefaultBulletList contains standards, which can be used to print a BulletListPrinter.
+var DefaultBulletList = BulletListPrinter{
 	Bullet:      "•",
 	TextStyle:   &ThemeDefault.BulletListTextStyle,
 	BulletStyle: &ThemeDefault.BulletListBulletStyle,
 }
 
-// BulletList is able to render a list.
-type BulletList struct {
+// BulletListPrinter is able to render a list.
+type BulletListPrinter struct {
 	Items       []BulletListItem
 	TextStyle   *Style
 	Bullet      string
@@ -107,31 +91,31 @@ type BulletList struct {
 }
 
 // WithItems returns a new list with specific Items.
-func (l BulletList) WithItems(items []BulletListItem) *BulletList {
+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 BulletList) WithTextStyle(style *Style) *BulletList {
+func (l BulletListPrinter) WithTextStyle(style *Style) *BulletListPrinter {
 	l.TextStyle = style
 	return &l
 }
 
 // WithBullet returns a new list with a specific bullet.
-func (l BulletList) WithBullet(bullet string) *BulletList {
+func (l BulletListPrinter) WithBullet(bullet string) *BulletListPrinter {
 	l.Bullet = bullet
 	return &l
 }
 
 // WithBulletStyle returns a new list with a specific bullet style.
-func (l BulletList) WithBulletStyle(style *Style) *BulletList {
+func (l BulletListPrinter) WithBulletStyle(style *Style) *BulletListPrinter {
 	l.BulletStyle = style
 	return &l
 }
 
 // Render prints the list to the terminal.
-func (l BulletList) Render() error {
+func (l BulletListPrinter) Render() error {
 	s, _ := l.Srender()
 	Println(s)
 
@@ -139,13 +123,27 @@ func (l BulletList) Render() error {
 }
 
 // Srender renders the list as a string.
-func (l BulletList) Srender() (string, error) {
+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
+			}
+		}
 		if item.Bullet == "" {
-			ret += item.WithBullet(l.Bullet).Srender() + "\n"
+			ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(l.Bullet) + " " + item.TextStyle.Sprint(item.Text) + "\n"
 		} else {
-			ret += item.WithBullet(item.Bullet).Srender() + "\n"
+			ret += strings.Repeat(" ", item.Level) + item.BulletStyle.Sprint(item.Bullet) + " " + item.TextStyle.Sprint(item.Text) + "\n"
 		}
 	}
 	return ret, nil
diff --git a/print.go b/print.go
index 4b70cc54..7057267f 100644
--- a/print.go
+++ b/print.go
@@ -44,7 +44,7 @@ func Print(a ...interface{}) {
 	var ret string
 	var printed bool
 
-	for _, bar := range ActiveProgressBars {
+	for _, bar := range ActiveProgressBarPrinters {
 		if bar.IsActive {
 			ret += sClearLine()
 			ret += Sprinto(a...)
diff --git a/progressbar.go b/progressbar_printer.go
similarity index 60%
rename from progressbar.go
rename to progressbar_printer.go
index 93d97750..25cbcd7a 100644
--- a/progressbar.go
+++ b/progressbar_printer.go
@@ -10,13 +10,13 @@ import (
 	"github.com/pterm/pterm/internal"
 )
 
-// ActiveProgressBars contains all running progressbars.
-// Generally, there should only be one active Progressbar at a time.
-var ActiveProgressBars []*Progressbar
+// ActiveProgressBarPrinters contains all running ProgressbarPrinters.
+// Generally, there should only be one active ProgressbarPrinter at a time.
+var ActiveProgressBarPrinters []*ProgressbarPrinter
 
 var (
-	// DefaultProgressbar is the default progressbar.
-	DefaultProgressbar = Progressbar{
+	// DefaultProgressbar is the default ProgressbarPrinter.
+	DefaultProgressbar = ProgressbarPrinter{
 		Total:                     100,
 		BarCharacter:              "█",
 		LastCharacter:             "█",
@@ -31,8 +31,8 @@ var (
 	}
 )
 
-// Progressbar shows a progress animation in the terminal.
-type Progressbar struct {
+// ProgressbarPrinter shows a progress animation in the terminal.
+type ProgressbarPrinter struct {
 	Title                     string
 	Total                     int
 	Current                   int
@@ -55,92 +55,92 @@ type Progressbar struct {
 	startedAt time.Time
 }
 
-// WithTitle sets the name of the progressbar.
-func (p Progressbar) WithTitle(name string) *Progressbar {
+// WithTitle sets the name of the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithTitle(name string) *ProgressbarPrinter {
 	p.Title = name
 	return &p
 }
 
-// WithTotal sets the total value of the progressbar.
-func (p Progressbar) WithTotal(total int) *Progressbar {
+// WithTotal sets the total value of the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithTotal(total int) *ProgressbarPrinter {
 	p.Total = total
 	return &p
 }
 
-// WithCurrent sets the current value of the progressbar.
-func (p Progressbar) WithCurrent(current int) *Progressbar {
+// WithCurrent sets the current value of the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithCurrent(current int) *ProgressbarPrinter {
 	p.Current = current
 	return &p
 }
 
-// WithBarCharacter sets the bar character of the progressbar.
-func (p Progressbar) WithBarCharacter(char string) *Progressbar {
+// WithBarCharacter sets the bar character of the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithBarCharacter(char string) *ProgressbarPrinter {
 	p.BarCharacter = char
 	return &p
 }
 
-// WithLastCharacter sets the last character of the progressbar.
-func (p Progressbar) WithLastCharacter(char string) *Progressbar {
+// WithLastCharacter sets the last character of the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithLastCharacter(char string) *ProgressbarPrinter {
 	p.LastCharacter = char
 	return &p
 }
 
 // WithElapsedTimeRoundingFactor sets the rounding factor of the elapsed time.
-func (p Progressbar) WithElapsedTimeRoundingFactor(duration time.Duration) *Progressbar {
+func (p ProgressbarPrinter) WithElapsedTimeRoundingFactor(duration time.Duration) *ProgressbarPrinter {
 	p.ElapsedTimeRoundingFactor = duration
 	return &p
 }
 
-// WithShowElapsedTime sets if the elapsed time should be displayed in the progressbar.
-func (p Progressbar) WithShowElapsedTime(b ...bool) *Progressbar {
+// WithShowElapsedTime sets if the elapsed time should be displayed in the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithShowElapsedTime(b ...bool) *ProgressbarPrinter {
 	p.ShowElapsedTime = internal.WithBoolean(b)
 	return &p
 }
 
-// WithShowCount sets if the total and current count should be displayed in the progressbar.
-func (p Progressbar) WithShowCount(b ...bool) *Progressbar {
+// WithShowCount sets if the total and current count should be displayed in the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithShowCount(b ...bool) *ProgressbarPrinter {
 	p.ShowCount = internal.WithBoolean(b)
 	return &p
 }
 
-// WithShowTitle sets if the title should be displayed in the progressbar.
-func (p Progressbar) WithShowTitle(b ...bool) *Progressbar {
+// WithShowTitle sets if the title should be displayed in the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithShowTitle(b ...bool) *ProgressbarPrinter {
 	p.ShowTitle = internal.WithBoolean(b)
 	return &p
 }
 
-// WithShowPercentage sets if the completed percentage should be displayed in the progressbar.
-func (p Progressbar) WithShowPercentage(b ...bool) *Progressbar {
+// WithShowPercentage sets if the completed percentage should be displayed in the ProgressbarPrinter.
+func (p ProgressbarPrinter) WithShowPercentage(b ...bool) *ProgressbarPrinter {
 	p.ShowPercentage = internal.WithBoolean(b)
 	return &p
 }
 
 // WithTitleStyle sets the style of the title.
-func (p Progressbar) WithTitleStyle(style *Style) *Progressbar {
+func (p ProgressbarPrinter) WithTitleStyle(style *Style) *ProgressbarPrinter {
 	p.TitleStyle = style
 	return &p
 }
 
 // WithBarStyle sets the style of the bar.
-func (p Progressbar) WithBarStyle(style *Style) *Progressbar {
+func (p ProgressbarPrinter) WithBarStyle(style *Style) *ProgressbarPrinter {
 	p.BarStyle = style
 	return &p
 }
 
-// WithRemoveWhenDone sets if the progressbar should be removed when it is done.
-func (p Progressbar) WithRemoveWhenDone(b ...bool) *Progressbar {
+// WithRemoveWhenDone sets if the ProgressbarPrinter should be removed when it is done.
+func (p ProgressbarPrinter) WithRemoveWhenDone(b ...bool) *ProgressbarPrinter {
 	p.RemoveWhenDone = internal.WithBoolean(b)
 	return &p
 }
 
 // Increment current value by one.
-func (p *Progressbar) Increment() *Progressbar {
+func (p *ProgressbarPrinter) Increment() *ProgressbarPrinter {
 	p.Add(1)
 	return p
 }
 
 // Add to current value.
-func (p *Progressbar) Add(count int) *Progressbar {
+func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter {
 	if p.TitleStyle == nil {
 		p.TitleStyle = NewStyle()
 	}
@@ -196,10 +196,10 @@ func (p *Progressbar) Add(count int) *Progressbar {
 	return p
 }
 
-// Start the progressbar.
-func (p Progressbar) Start() (*Progressbar, error) {
+// Start the ProgressbarPrinter.
+func (p ProgressbarPrinter) Start() (*ProgressbarPrinter, error) {
 	p.IsActive = true
-	ActiveProgressBars = append(ActiveProgressBars, &p)
+	ActiveProgressBarPrinters = append(ActiveProgressBarPrinters, &p)
 	p.startedAt = time.Now()
 
 	p.Add(0)
@@ -207,8 +207,8 @@ func (p Progressbar) Start() (*Progressbar, error) {
 	return &p, nil
 }
 
-// Stop the progressbar.
-func (p *Progressbar) Stop() (*Progressbar, error) {
+// Stop the ProgressbarPrinter.
+func (p *ProgressbarPrinter) Stop() (*ProgressbarPrinter, error) {
 	if !p.IsActive {
 		return p, nil
 	}
@@ -225,7 +225,7 @@ func (p *Progressbar) Stop() (*Progressbar, error) {
 // 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 Progressbar) GenericStart() (*LivePrinter, error) {
+func (p ProgressbarPrinter) GenericStart() (*LivePrinter, error) {
 	p2, _ := p.Start()
 	lp := LivePrinter(p2)
 	return &lp, nil
@@ -234,18 +234,18 @@ func (p Progressbar) GenericStart() (*LivePrinter, error) {
 // 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 Progressbar) GenericStop() (*LivePrinter, error) {
+func (p ProgressbarPrinter) GenericStop() (*LivePrinter, error) {
 	p2, _ := p.Stop()
 	lp := LivePrinter(p2)
 	return &lp, nil
 }
 
-// GetElapsedTime returns the elapsed time, since the progressbar was started.
-func (p *Progressbar) GetElapsedTime() time.Duration {
+// GetElapsedTime returns the elapsed time, since the ProgressbarPrinter was started.
+func (p *ProgressbarPrinter) GetElapsedTime() time.Duration {
 	return time.Since(p.startedAt)
 }
 
-func (p *Progressbar) parseElapsedTime() string {
+func (p *ProgressbarPrinter) parseElapsedTime() string {
 	s := p.GetElapsedTime().Round(p.ElapsedTimeRoundingFactor).String()
 	return s
 }
diff --git a/spinner.go b/spinner_printer.go
similarity index 55%
rename from spinner.go
rename to spinner_printer.go
index 028af6f4..3854de73 100644
--- a/spinner.go
+++ b/spinner_printer.go
@@ -6,8 +6,8 @@ import (
 	"github.com/pterm/pterm/internal"
 )
 
-// DefaultSpinner is the default spinner.
-var DefaultSpinner = Spinner{
+// DefaultSpinner is the default SpinnerPrinter.
+var DefaultSpinner = SpinnerPrinter{
 	Sequence:       []string{"▀ ", " ▀", " ▄", "▄ "},
 	Style:          &ThemeDefault.SpinnerStyle,
 	Delay:          time.Millisecond * 200,
@@ -17,10 +17,10 @@ var DefaultSpinner = Spinner{
 	WarningPrinter: &Warning,
 }
 
-// Spinner is a loading animation, which can be used if the progress is unknown.
+// SpinnerPrinter is a loading animation, which can be used if the progress is unknown.
 // It's an animation loop, which can have a text and supports throwing errors or warnings.
-// A TextPrinter is used to display all outputs, after the spinner is done.
-type Spinner struct {
+// A TextPrinter is used to display all outputs, after the SpinnerPrinter is done.
+type SpinnerPrinter struct {
 	Text           string
 	Sequence       []string
 	Style          *Style
@@ -34,51 +34,51 @@ type Spinner struct {
 	IsActive bool
 }
 
-// WithText adds a text to the spinner.
-func (s Spinner) WithText(text string) *Spinner {
+// WithText adds a text to the SpinnerPrinter.
+func (s SpinnerPrinter) WithText(text string) *SpinnerPrinter {
 	s.Text = text
 	return &s
 }
 
-// WithSequence adds a sequence to the spinner.
-func (s Spinner) WithSequence(sequence ...string) *Spinner {
+// WithSequence adds a sequence to the SpinnerPrinter.
+func (s SpinnerPrinter) WithSequence(sequence ...string) *SpinnerPrinter {
 	s.Sequence = sequence
 	return &s
 }
 
-// WithStyle adds a style to the spinner.
-func (s Spinner) WithStyle(style *Style) *Spinner {
+// WithStyle adds a style to the SpinnerPrinter.
+func (s SpinnerPrinter) WithStyle(style *Style) *SpinnerPrinter {
 	s.Style = style
 	return &s
 }
 
-// WithDelay adds a delay to the spinner.
-func (s Spinner) WithDelay(delay time.Duration) *Spinner {
+// WithDelay adds a delay to the SpinnerPrinter.
+func (s SpinnerPrinter) WithDelay(delay time.Duration) *SpinnerPrinter {
 	s.Delay = delay
 	return &s
 }
 
-// WithMessageStyle adds a style to the spinner message.
-func (s Spinner) WithMessageStyle(style *Style) *Spinner {
+// WithMessageStyle adds a style to the SpinnerPrinter message.
+func (s SpinnerPrinter) WithMessageStyle(style *Style) *SpinnerPrinter {
 	s.MessageStyle = style
 	return &s
 }
 
-// WithRemoveWhenDone removes the spinner after it is done.
-func (s Spinner) WithRemoveWhenDone(b ...bool) *Spinner {
+// WithRemoveWhenDone removes the SpinnerPrinter after it is done.
+func (s SpinnerPrinter) WithRemoveWhenDone(b ...bool) *SpinnerPrinter {
 	s.RemoveWhenDone = internal.WithBoolean(b)
 	return &s
 }
 
-// UpdateText updates the message of the active spinner.
+// UpdateText updates the message of the active SpinnerPrinter.
 // Can be used live.
-func (s *Spinner) UpdateText(text string) {
+func (s *SpinnerPrinter) UpdateText(text string) {
 	clearLine()
 	s.Text = text
 }
 
-// Start the spinner.
-func (s Spinner) Start(text ...interface{}) (*Spinner, error) {
+// Start the SpinnerPrinter.
+func (s SpinnerPrinter) Start(text ...interface{}) (*SpinnerPrinter, error) {
 	s.IsActive = true
 
 	if len(text) != 0 {
@@ -98,9 +98,9 @@ func (s Spinner) Start(text ...interface{}) (*Spinner, error) {
 	return &s, nil
 }
 
-// Stop terminates the Spinner immediately.
-// The Spinner will not resolve into anything.
-func (s *Spinner) Stop() error {
+// Stop terminates the SpinnerPrinter immediately.
+// The SpinnerPrinter will not resolve into anything.
+func (s *SpinnerPrinter) Stop() error {
 	s.IsActive = false
 	if s.RemoveWhenDone {
 		clearLine()
@@ -114,7 +114,7 @@ func (s *Spinner) Stop() error {
 // 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 *Spinner) GenericStart() (*LivePrinter, error) {
+func (s *SpinnerPrinter) GenericStart() (*LivePrinter, error) {
 	_, _ = s.Start()
 	lp := LivePrinter(s)
 	return &lp, nil
@@ -123,15 +123,15 @@ func (s *Spinner) GenericStart() (*LivePrinter, error) {
 // 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 *Spinner) GenericStop() (*LivePrinter, error) {
+func (s *SpinnerPrinter) GenericStop() (*LivePrinter, error) {
 	_ = s.Stop()
 	lp := LivePrinter(s)
 	return &lp, nil
 }
 
 // Success displays the success printer.
-// If no message is given, the text of the spinner will be reused as the default message.
-func (s *Spinner) Success(message ...interface{}) {
+// If no message is given, the text of the SpinnerPrinter will be reused as the default message.
+func (s *SpinnerPrinter) Success(message ...interface{}) {
 	if s.SuccessPrinter == nil {
 		s.SuccessPrinter = &Success
 	}
@@ -145,8 +145,8 @@ func (s *Spinner) Success(message ...interface{}) {
 }
 
 // Fail displays the fail printer.
-// If no message is given, the text of the spinner will be reused as the default message.
-func (s *Spinner) Fail(message ...interface{}) {
+// If no message is given, the text of the SpinnerPrinter will be reused as the default message.
+func (s *SpinnerPrinter) Fail(message ...interface{}) {
 	if s.FailPrinter == nil {
 		s.FailPrinter = &Error
 	}
@@ -160,8 +160,8 @@ func (s *Spinner) Fail(message ...interface{}) {
 }
 
 // Warning displays the warning printer.
-// If no message is given, the text of the spinner will be reused as the default message.
-func (s *Spinner) Warning(message ...interface{}) {
+// If no message is given, the text of the SpinnerPrinter will be reused as the default message.
+func (s *SpinnerPrinter) Warning(message ...interface{}) {
 	if s.WarningPrinter == nil {
 		s.WarningPrinter = &Warning
 	}
diff --git a/table_printer.go b/table_printer.go
index af1c4c61..4a01a2fb 100644
--- a/table_printer.go
+++ b/table_printer.go
@@ -7,19 +7,19 @@ import (
 	"github.com/pterm/pterm/internal"
 )
 
-// DefaultTable contains standards, which can be used to print a Table.
-var DefaultTable = Table{
+// DefaultTable contains standards, which can be used to print a TablePrinter.
+var DefaultTable = TablePrinter{
 	Style:          &ThemeDefault.TableStyle,
 	HeaderStyle:    &ThemeDefault.TableHeaderStyle,
 	Separator:      " | ",
 	SeparatorStyle: &ThemeDefault.TableSeparatorStyle,
 }
 
-// TableData is the type that contains the data of a Table.
+// TableData is the type that contains the data of a TablePrinter.
 type TableData [][]string
 
-// Table is able to render tables.
-type Table struct {
+// TablePrinter is able to render tables.
+type TablePrinter struct {
 	Style          *Style
 	HasHeader      bool
 	HeaderStyle    *Style
@@ -28,52 +28,52 @@ type Table struct {
 	Data           TableData
 }
 
-// WithStyle returns a new Table with a specific Style.
-func (p Table) WithStyle(style *Style) *Table {
+// WithStyle returns a new TablePrinter with a specific Style.
+func (p TablePrinter) WithStyle(style *Style) *TablePrinter {
 	p.Style = style
 	return &p
 }
 
-// WithHasHeader returns a new Table, where the first line is marked as a header.
-func (p Table) WithHasHeader(b ...bool) *Table {
+// WithHasHeader returns a new TablePrinter, where the first line is marked as a header.
+func (p TablePrinter) WithHasHeader(b ...bool) *TablePrinter {
 	p.HasHeader = internal.WithBoolean(b)
 	return &p
 }
 
-// WithHeaderStyle returns a new Table with a specific HeaderStyle.
-func (p Table) WithHeaderStyle(style *Style) *Table {
+// WithHeaderStyle returns a new TablePrinter with a specific HeaderStyle.
+func (p TablePrinter) WithHeaderStyle(style *Style) *TablePrinter {
 	p.HeaderStyle = style
 	return &p
 }
 
-// WithSeparator returns a new Table with a specific separator.
-func (p Table) WithSeparator(separator string) *Table {
+// WithSeparator returns a new TablePrinter with a specific separator.
+func (p TablePrinter) WithSeparator(separator string) *TablePrinter {
 	p.Separator = separator
 	return &p
 }
 
-// WithSeparatorStyle returns a new Table with a specific SeparatorStyle.
-func (p Table) WithSeparatorStyle(style *Style) *Table {
+// WithSeparatorStyle returns a new TablePrinter with a specific SeparatorStyle.
+func (p TablePrinter) WithSeparatorStyle(style *Style) *TablePrinter {
 	p.SeparatorStyle = style
 	return &p
 }
 
-// WithData returns a new Table with specific Data.
-func (p Table) WithData(data [][]string) *Table {
+// WithData returns a new TablePrinter with specific Data.
+func (p TablePrinter) WithData(data [][]string) *TablePrinter {
 	p.Data = data
 	return &p
 }
 
-// WithCSVReader return a new Table with specified Data extracted from CSV.
-func (p Table) WithCSVReader(reader *csv.Reader) *Table {
+// WithCSVReader return a new TablePrinter with specified Data extracted from CSV.
+func (p TablePrinter) WithCSVReader(reader *csv.Reader) *TablePrinter {
 	if records, err := reader.ReadAll(); err == nil {
 		p.Data = records
 	}
 	return &p
 }
 
-// Srender renders the Table as a string.
-func (p Table) Srender() (string, error) {
+// Srender renders the TablePrinter as a string.
+func (p TablePrinter) Srender() (string, error) {
 	if p.Style == nil {
 		p.Style = NewStyle()
 	}
@@ -120,8 +120,8 @@ func (p Table) Srender() (string, error) {
 	return ret, nil
 }
 
-// Render prints the Table to the terminal.
-func (p Table) Render() error {
+// Render prints the TablePrinter to the terminal.
+func (p TablePrinter) Render() error {
 	s, _ := p.Srender()
 	Println(s)
 
diff --git a/tree_printer.go b/tree_printer.go
index 23b0dfe2..d12f4e9a 100644
--- a/tree_printer.go
+++ b/tree_printer.go
@@ -4,7 +4,7 @@ import (
 	"strings"
 )
 
-// TreeNode is used as items in a Tree.
+// TreeNode is used as items in a TreePrinter.
 type TreeNode struct {
 	Children []TreeNode
 	Text     string
@@ -14,14 +14,14 @@ type TreeNode struct {
 type LeveledList []LeveledListItem
 
 // LeveledListItem combines a text with a specific level.
-// The level is the indent, which would normally be seen in a BulletList.
+// The level is the indent, which would normally be seen in a BulletListPrinter.
 type LeveledListItem struct {
 	Level int
 	Text  string
 }
 
-// DefaultTree contains standards, which can be used to render a Tree.
-var DefaultTree = Tree{
+// DefaultTree contains standards, which can be used to render a TreePrinter.
+var DefaultTree = TreePrinter{
 	TreeStyle:            &ThemeDefault.TreeStyle,
 	TextStyle:            &ThemeDefault.TreeTextStyle,
 	TopRightCornerString: "└",
@@ -32,8 +32,8 @@ var DefaultTree = Tree{
 	Indent:               2,
 }
 
-// Tree is able to render a list.
-type Tree struct {
+// TreePrinter is able to render a list.
+type TreePrinter struct {
 	Root                 TreeNode
 	TreeStyle            *Style
 	TextStyle            *Style
@@ -46,50 +46,50 @@ type Tree struct {
 }
 
 // WithTreeStyle returns a new list with a specific tree style.
-func (p Tree) WithTreeStyle(style *Style) *Tree {
+func (p TreePrinter) WithTreeStyle(style *Style) *TreePrinter {
 	p.TreeStyle = style
 	return &p
 }
 
 // WithTextStyle returns a new list with a specific text style.
-func (p Tree) WithTextStyle(style *Style) *Tree {
+func (p TreePrinter) WithTextStyle(style *Style) *TreePrinter {
 	p.TextStyle = style
 	return &p
 }
 
 // WithTopRightCornerString returns a new list with a specific TopRightCornerString.
-func (p Tree) WithTopRightCornerString(s string) *Tree {
+func (p TreePrinter) WithTopRightCornerString(s string) *TreePrinter {
 	p.TopRightCornerString = s
 	return &p
 }
 
 // WithTopRightDownStringOngoing returns a new list with a specific TopRightDownString.
-func (p Tree) WithTopRightDownStringOngoing(s string) *Tree {
+func (p TreePrinter) WithTopRightDownStringOngoing(s string) *TreePrinter {
 	p.TopRightDownString = s
 	return &p
 }
 
 // WithHorizontalString returns a new list with a specific HorizontalString.
-func (p Tree) WithHorizontalString(s string) *Tree {
+func (p TreePrinter) WithHorizontalString(s string) *TreePrinter {
 	p.HorizontalString = s
 	return &p
 }
 
 // WithVerticalString returns a new list with a specific VerticalString.
-func (p Tree) WithVerticalString(s string) *Tree {
+func (p TreePrinter) WithVerticalString(s string) *TreePrinter {
 	p.VerticalString = s
 	return &p
 }
 
 // WithRoot returns a new list with a specific Root.
-func (p Tree) WithRoot(root TreeNode) *Tree {
+func (p TreePrinter) WithRoot(root TreeNode) *TreePrinter {
 	p.Root = root
 	return &p
 }
 
 // WithIndent returns a new list with a specific amount of spacing between the levels.
 // Indent must be at least 1.
-func (p Tree) WithIndent(indent int) *Tree {
+func (p TreePrinter) WithIndent(indent int) *TreePrinter {
 	if indent < 1 {
 		indent = 1
 	}
@@ -98,7 +98,7 @@ func (p Tree) WithIndent(indent int) *Tree {
 }
 
 // Render prints the list to the terminal.
-func (p Tree) Render() error {
+func (p TreePrinter) Render() error {
 	s, _ := p.Srender()
 	Println(s)
 
@@ -106,7 +106,7 @@ func (p Tree) Render() error {
 }
 
 // Srender renders the list as a string.
-func (p Tree) Srender() (string, error) {
+func (p TreePrinter) Srender() (string, error) {
 	if p.TreeStyle == nil {
 		p.TreeStyle = NewStyle()
 	}
@@ -118,9 +118,9 @@ func (p Tree) Srender() (string, error) {
 }
 
 // walkOverTree is a recursive function,
-// which analyzes a Tree and connects the items with specific characters.
-// Returns Tree as string.
-func walkOverTree(list []TreeNode, p Tree, prefix string) string {
+// which analyzes a TreePrinter and connects the items with specific characters.
+// Returns TreePrinter as string.
+func walkOverTree(list []TreeNode, p TreePrinter, prefix string) string {
 	var ret string
 	for i, item := range list {
 		if len(list) > i+1 { // if not last in list


Test patch:
diff --git a/bulletlist_printer_test.go b/bulletlist_printer_test.go
index 7551716b..072423c5 100644
--- a/bulletlist_printer_test.go
+++ b/bulletlist_printer_test.go
@@ -11,11 +11,11 @@ import (
 )
 
 func TestBulletListPrinterNilPrint(t *testing.T) {
-	p := BulletList{}
+	p := BulletListPrinter{}
 	p.Render()
 }
 
-func TestBulletList_Render(t *testing.T) {
+func TestBulletListPrinter_Render(t *testing.T) {
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		DefaultBulletList.WithItems([]BulletListItem{
 			{Level: 0, Text: fmt.Sprint(a)},
@@ -23,7 +23,15 @@ func TestBulletList_Render(t *testing.T) {
 	})
 }
 
-func TestBulletList_RenderWithBullet(t *testing.T) {
+func TestBulletListPrinter_RenderWithoutStyle(t *testing.T) {
+	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
+		BulletListPrinter{}.WithItems([]BulletListItem{
+			{Level: 0, Text: fmt.Sprint(a)},
+		}).Render()
+	})
+}
+
+func TestBulletListPrinter_RenderWithBullet(t *testing.T) {
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		DefaultBulletList.WithItems([]BulletListItem{
 			{
@@ -35,7 +43,7 @@ func TestBulletList_RenderWithBullet(t *testing.T) {
 	})
 }
 
-func TestBulletList_Srender(t *testing.T) {
+func TestBulletListPrinter_Srender(t *testing.T) {
 	internal.TestSprintContainsWithoutError(t, func(a interface{}) (string, error) {
 		return DefaultBulletList.WithItems([]BulletListItem{
 			{Level: 0, Text: fmt.Sprint(a)},
@@ -43,16 +51,16 @@ func TestBulletList_Srender(t *testing.T) {
 	})
 }
 
-func TestBulletList_WithBullet(t *testing.T) {
-	p := BulletList{}
+func TestBulletListPrinter_WithBullet(t *testing.T) {
+	p := BulletListPrinter{}
 	p2 := p.WithBullet("-")
 
 	assert.Equal(t, "-", p2.Bullet)
 	assert.Empty(t, p.Bullet)
 }
 
-func TestBulletList_WithBulletStyle(t *testing.T) {
-	p := BulletList{}
+func TestBulletListPrinter_WithBulletStyle(t *testing.T) {
+	p := BulletListPrinter{}
 	s := NewStyle(FgRed, BgRed, Bold)
 	p2 := p.WithBulletStyle(s)
 
@@ -60,8 +68,8 @@ func TestBulletList_WithBulletStyle(t *testing.T) {
 	assert.Empty(t, p.BulletStyle)
 }
 
-func TestBulletList_WithItems(t *testing.T) {
-	p := BulletList{}
+func TestBulletListPrinter_WithItems(t *testing.T) {
+	p := BulletListPrinter{}
 	li := []BulletListItem{{
 		Level:       0,
 		Text:        "test",
@@ -75,8 +83,8 @@ func TestBulletList_WithItems(t *testing.T) {
 	assert.Empty(t, p.Items)
 }
 
-func TestBulletList_WithTextStyle(t *testing.T) {
-	p := BulletList{}
+func TestBulletListPrinter_WithTextStyle(t *testing.T) {
+	p := BulletListPrinter{}
 	s := NewStyle(FgRed, BgRed, Bold)
 	p2 := p.WithTextStyle(s)
 
@@ -84,18 +92,6 @@ func TestBulletList_WithTextStyle(t *testing.T) {
 	assert.Empty(t, p.TextStyle)
 }
 
-func TestBulletListItem_Render(t *testing.T) {
-	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
-		DefaultListItem.WithText(fmt.Sprint(a)).Render()
-	})
-}
-
-func TestBulletListItem_Srender(t *testing.T) {
-	internal.TestSprintContains(t, func(a interface{}) string {
-		return DefaultListItem.WithText(fmt.Sprint(a)).Srender()
-	})
-}
-
 func TestBulletListItem_WithBullet(t *testing.T) {
 	p := BulletListItem{}
 	p2 := p.WithBullet("-")
diff --git a/progressbar_test.go b/progressbar_printer_test.go
similarity index 53%
rename from progressbar_test.go
rename to progressbar_printer_test.go
index e256e51a..1ee3941f 100644
--- a/progressbar_test.go
+++ b/progressbar_printer_test.go
@@ -6,14 +6,14 @@ import (
 	"time"
 )
 
-func TestProgressbar_Add(t *testing.T) {
+func TestProgressbarPrinter_Add(t *testing.T) {
 	p := DefaultProgressbar.WithTotal(2000)
 	p.Add(1337)
 	assert.Equal(t, 1337, p.Current)
 	p.Stop()
 }
 
-func TestProgressbar_AddTotalEqualsCurrent(t *testing.T) {
+func TestProgressbarPrinter_AddTotalEqualsCurrent(t *testing.T) {
 	p := DefaultProgressbar.WithTotal(1)
 	p.Start()
 	p.Add(1)
@@ -22,7 +22,7 @@ func TestProgressbar_AddTotalEqualsCurrent(t *testing.T) {
 	p.Stop()
 }
 
-func TestProgressbarRemoveWhenDone(t *testing.T) {
+func TestProgressbarPrinter_RemoveWhenDone(t *testing.T) {
 	p, err := DefaultProgressbar.WithTotal(2).WithRemoveWhenDone().Start()
 	assert.NoError(t, err)
 	p.Stop()
@@ -31,125 +31,125 @@ func TestProgressbarRemoveWhenDone(t *testing.T) {
 	assert.False(t, p.IsActive)
 }
 
-func TestProgressbar_GenericStart(t *testing.T) {
+func TestProgressbarPrinter_GenericStart(t *testing.T) {
 	p := DefaultProgressbar
 	p.GenericStart()
 }
 
-func TestProgressbar_GenericStop(t *testing.T) {
+func TestProgressbarPrinter_GenericStop(t *testing.T) {
 	p, err := DefaultProgressbar.Start()
 	assert.NoError(t, err)
 	p.GenericStop()
 }
 
-func TestProgressbar_GetElapsedTime(t *testing.T) {
+func TestProgressbarPrinter_GetElapsedTime(t *testing.T) {
 	p := DefaultProgressbar
 	p.Start()
 	p.Stop()
 	assert.NotEmpty(t, p.GetElapsedTime())
 }
 
-func TestProgressbar_Increment(t *testing.T) {
+func TestProgressbarPrinter_Increment(t *testing.T) {
 	p := DefaultProgressbar.WithTotal(2000)
 	p.Increment()
 	assert.Equal(t, 1, p.Current)
 }
 
-func TestProgressbar_WithBarStyle(t *testing.T) {
+func TestProgressbarPrinter_WithBarStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Progressbar{}
+	p := ProgressbarPrinter{}
 	p2 := p.WithBarStyle(s)
 
 	assert.Equal(t, s, p2.BarStyle)
 }
 
-func TestProgressbar_WithCurrent(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithCurrent(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithCurrent(10)
 
 	assert.Equal(t, 10, p2.Current)
 }
 
-func TestProgressbar_WithElapsedTimeRoundingFactor(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithElapsedTimeRoundingFactor(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithElapsedTimeRoundingFactor(time.Hour)
 
 	assert.Equal(t, time.Hour, p2.ElapsedTimeRoundingFactor)
 }
 
-func TestProgressbar_WithLastCharacter(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithLastCharacter(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithLastCharacter(">")
 
 	assert.Equal(t, ">", p2.LastCharacter)
 }
 
-func TestProgressbar_WithBarCharacter(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithBarCharacter(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithBarCharacter("-")
 
 	assert.Equal(t, "-", p2.BarCharacter)
 }
 
-func TestProgressbar_WithRemoveWhenDone(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithRemoveWhenDone(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithRemoveWhenDone()
 
 	assert.True(t, p2.RemoveWhenDone)
 }
 
-func TestProgressbar_WithShowCount(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithShowCount(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithShowCount()
 
 	assert.True(t, p2.ShowCount)
 }
 
-func TestProgressbar_WithShowElapsedTime(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithShowElapsedTime(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithShowElapsedTime()
 
 	assert.True(t, p2.ShowElapsedTime)
 }
 
-func TestProgressbar_WithShowPercentage(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithShowPercentage(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithShowPercentage()
 
 	assert.True(t, p2.ShowPercentage)
 }
 
-func TestProgressbar_WithShowTitle(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithShowTitle(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithShowTitle()
 
 	assert.True(t, p2.ShowTitle)
 }
 
-func TestProgressbar_WithTitle(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithTitle(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithTitle("test")
 
 	assert.Equal(t, "test", p2.Title)
 }
 
-func TestProgressbar_WithTitleStyle(t *testing.T) {
+func TestProgressbarPrinter_WithTitleStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Progressbar{}
+	p := ProgressbarPrinter{}
 	p2 := p.WithTitleStyle(s)
 
 	assert.Equal(t, s, p2.TitleStyle)
 }
 
-func TestProgressbar_WithTotal(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_WithTotal(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p2 := p.WithTotal(1337)
 
 	assert.Equal(t, 1337, p2.Total)
 }
 
-func TestProgressbar_parseElapsedTime(t *testing.T) {
-	p := Progressbar{}
+func TestProgressbarPrinter_parseElapsedTime(t *testing.T) {
+	p := ProgressbarPrinter{}
 	p.Start()
 	p.Stop()
 	assert.NotEmpty(t, p.parseElapsedTime())
diff --git a/spinner_test.go b/spinner_printer_test.go
similarity index 71%
rename from spinner_test.go
rename to spinner_printer_test.go
index 32cb0018..728abbc4 100644
--- a/spinner_test.go
+++ b/spinner_printer_test.go
@@ -8,38 +8,38 @@ import (
 	"time"
 )
 
-func TestSpinnerPrinterNilPrint(t *testing.T) {
-	p := Spinner{}
+func TestSpinnerPrinter_NilPrint(t *testing.T) {
+	p := SpinnerPrinter{}
 	p.Success()
 	p.Warning()
 	p.Fail()
 }
 
-func TestSpinner_Fail(t *testing.T) {
+func TestSpinnerPrinter_Fail(t *testing.T) {
 	p := DefaultSpinner
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		p.Fail(a)
 	})
 }
 
-func TestSpinner_GenericStart(t *testing.T) {
+func TestSpinnerPrinter_GenericStart(t *testing.T) {
 	p := DefaultSpinner
 	p.GenericStart()
 }
 
-func TestSpinner_GenericStop(t *testing.T) {
+func TestSpinnerPrinter_GenericStop(t *testing.T) {
 	p := DefaultSpinner
 	p.GenericStop()
 }
 
-func TestSpinner_Success(t *testing.T) {
+func TestSpinnerPrinter_Success(t *testing.T) {
 	p := DefaultSpinner
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		p.Success(a)
 	})
 }
 
-func TestSpinner_UpdateText(t *testing.T) {
+func TestSpinnerPrinter_UpdateText(t *testing.T) {
 	p := DefaultSpinner
 	p.Start()
 	p.UpdateText("test")
@@ -48,58 +48,58 @@ func TestSpinner_UpdateText(t *testing.T) {
 	p.Stop()
 }
 
-func TestSpinner_Warning(t *testing.T) {
+func TestSpinnerPrinter_Warning(t *testing.T) {
 	p := DefaultSpinner
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		p.Warning(a)
 	})
 }
 
-func TestSpinner_WithDelay(t *testing.T) {
-	p := Spinner{}
+func TestSpinnerPrinter_WithDelay(t *testing.T) {
+	p := SpinnerPrinter{}
 	p2 := p.WithDelay(time.Second)
 
 	assert.Equal(t, time.Second, p2.Delay)
 }
 
-func TestSpinner_WithMessageStyle(t *testing.T) {
+func TestSpinnerPrinter_WithMessageStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Spinner{}
+	p := SpinnerPrinter{}
 	p2 := p.WithMessageStyle(s)
 
 	assert.Equal(t, s, p2.MessageStyle)
 }
 
-func TestSpinner_WithRemoveWhenDone(t *testing.T) {
-	p := Spinner{}
+func TestSpinnerPrinter_WithRemoveWhenDone(t *testing.T) {
+	p := SpinnerPrinter{}
 	p2 := p.WithRemoveWhenDone()
 
 	assert.True(t, p2.RemoveWhenDone)
 }
 
-func TestSpinner_WithSequence(t *testing.T) {
-	p := Spinner{}
+func TestSpinnerPrinter_WithSequence(t *testing.T) {
+	p := SpinnerPrinter{}
 	p2 := p.WithSequence("a", "b", "c")
 
 	assert.Equal(t, []string{"a", "b", "c"}, p2.Sequence)
 }
 
-func TestSpinner_WithStyle(t *testing.T) {
+func TestSpinnerPrinter_WithStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Spinner{}
+	p := SpinnerPrinter{}
 	p2 := p.WithStyle(s)
 
 	assert.Equal(t, s, p2.Style)
 }
 
-func TestSpinner_WithText(t *testing.T) {
-	p := Spinner{}
+func TestSpinnerPrinter_WithText(t *testing.T) {
+	p := SpinnerPrinter{}
 	p2 := p.WithText("test")
 
 	assert.Equal(t, "test", p2.Text)
 }
 
-func TestSpinnerDifferentVariations(t *testing.T) {
+func TestSpinnerPrinter_DifferentVariations(t *testing.T) {
 	type fields struct {
 		Text           string
 		Sequence       []string
@@ -126,7 +126,7 @@ func TestSpinnerDifferentVariations(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			s := Spinner{
+			s := SpinnerPrinter{
 				Text:           tt.fields.Text,
 				Sequence:       tt.fields.Sequence,
 				Style:          tt.fields.Style,
diff --git a/table_printer_test.go b/table_printer_test.go
index 745f122f..fa1e0f36 100644
--- a/table_printer_test.go
+++ b/table_printer_test.go
@@ -7,12 +7,12 @@ import (
 	"testing"
 )
 
-func TestTablePrinterNilPrint(t *testing.T) {
-	p := Table{}
+func TestTablePrinter_NilPrint(t *testing.T) {
+	p := TablePrinter{}
 	p.Render()
 }
 
-func TestTable_Render(t *testing.T) {
+func TestTablePrinter_Render(t *testing.T) {
 	DefaultTable.WithHasHeader().WithData(TableData{
 		{"Firstname", "Lastname", "Email"},
 		{"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk"},
@@ -21,59 +21,59 @@ func TestTable_Render(t *testing.T) {
 	}).Render()
 }
 
-func TestTable_WithCSVReader(t *testing.T) {
+func TestTablePrinter_WithCSVReader(t *testing.T) {
 	r := csv.NewReader(os.Stdin)
-	p := Table{}
+	p := TablePrinter{}
 	p2 := p.WithCSVReader(r)
 	p2.Srender()
 }
 
-func TestTable_WithData(t *testing.T) {
+func TestTablePrinter_WithData(t *testing.T) {
 	d := TableData{
 		{"Firstname", "Lastname", "Email"},
 		{"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk"},
 		{"Callie", "Mckay", "egestas.nunc.sed@est.com"},
 		{"Libby", "Camacho", "aliquet.lobortis@semper.com"},
 	}
-	p := Table{}
+	p := TablePrinter{}
 	p2 := p.WithData(d)
 
 	assert.Equal(t, d, p2.Data)
 }
 
-func TestTable_WithHasHeader(t *testing.T) {
-	p := Table{}
+func TestTablePrinter_WithHasHeader(t *testing.T) {
+	p := TablePrinter{}
 	p2 := p.WithHasHeader()
 
 	assert.True(t, p2.HasHeader)
 }
 
-func TestTable_WithHeaderStyle(t *testing.T) {
+func TestTablePrinter_WithHeaderStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Table{}
+	p := TablePrinter{}
 	p2 := p.WithHeaderStyle(s)
 
 	assert.Equal(t, s, p2.HeaderStyle)
 }
 
-func TestTable_WithSeparator(t *testing.T) {
-	p := Table{}
+func TestTablePrinter_WithSeparator(t *testing.T) {
+	p := TablePrinter{}
 	p2 := p.WithSeparator("-")
 
 	assert.Equal(t, "-", p2.Separator)
 }
 
-func TestTable_WithSeparatorStyle(t *testing.T) {
+func TestTablePrinter_WithSeparatorStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Table{}
+	p := TablePrinter{}
 	p2 := p.WithSeparatorStyle(s)
 
 	assert.Equal(t, s, p2.SeparatorStyle)
 }
 
-func TestTable_WithStyle(t *testing.T) {
+func TestTablePrinter_WithStyle(t *testing.T) {
 	s := NewStyle(FgRed, BgBlue, Bold)
-	p := Table{}
+	p := TablePrinter{}
 	p2 := p.WithStyle(s)
 
 	assert.Equal(t, s, p2.Style)
diff --git a/tree_printer_test.go b/tree_printer_test.go
index 3faae376..339d60c2 100644
--- a/tree_printer_test.go
+++ b/tree_printer_test.go
@@ -12,11 +12,11 @@ import (
 
 func TestTreePrinterNilPrint(t *testing.T) {
 	proxyToDevNull()
-	Tree{}.Render()
-	Tree{}.WithRoot(NewTreeFromLeveledList(LeveledList{LeveledListItem{Text: "Hello, World!", Level: 0}})).Render()
+	TreePrinter{}.Render()
+	TreePrinter{}.WithRoot(NewTreeFromLeveledList(LeveledList{LeveledListItem{Text: "Hello, World!", Level: 0}})).Render()
 }
 
-func TestTree_Render(t *testing.T) {
+func TestTreePrinter_Render(t *testing.T) {
 	internal.TestPrintContains(t, func(w io.Writer, a interface{}) {
 		DefaultTree.WithRoot(NewTreeFromLeveledList([]LeveledListItem{
 			{Level: 0, Text: fmt.Sprint(a)},
@@ -33,7 +33,7 @@ func TestTree_Render(t *testing.T) {
 	})
 }
 
-func TestTree_NewTreeFromLeveledList(t *testing.T) {
+func TestTreePrinter_NewTreeFromLeveledList(t *testing.T) {
 	p := DefaultTree
 	p2 := p.WithRoot(NewTreeFromLeveledList(LeveledList{
 		LeveledListItem{Level: 0, Text: "0.0"},
@@ -59,7 +59,7 @@ func TestTree_NewTreeFromLeveledList(t *testing.T) {
 	assert.Empty(t, p.Root)
 }
 
-func TestTree_NewTreeFromLeveledListLevelInvalidIncrease(t *testing.T) {
+func TestTreePrinter_NewTreeFromLeveledListLevelInvalidIncrease(t *testing.T) {
 	p := DefaultTree
 	p2 := p.WithRoot(NewTreeFromLeveledList(LeveledList{
 		LeveledListItem{Level: 0, Text: "0.0"},
@@ -85,7 +85,7 @@ func TestTree_NewTreeFromLeveledListLevelInvalidIncrease(t *testing.T) {
 	assert.Empty(t, p.Root)
 }
 
-func TestTree_NewTreeFromLeveledListEmptyList(t *testing.T) {
+func TestTreePrinter_NewTreeFromLeveledListEmptyList(t *testing.T) {
 	p := DefaultTree
 	p2 := p.WithRoot(NewTreeFromLeveledList(LeveledList{}))
 
@@ -93,7 +93,7 @@ func TestTree_NewTreeFromLeveledListEmptyList(t *testing.T) {
 	assert.Empty(t, p.Root)
 }
 
-func TestTree_NewTreeFromLeveledListNegativeLevel(t *testing.T) {
+func TestTreePrinter_NewTreeFromLeveledListNegativeLevel(t *testing.T) {
 	p := DefaultTree
 	p2 := p.WithRoot(NewTreeFromLeveledList(LeveledList{
 		LeveledListItem{Level: 0, Text: "0.0"},
@@ -119,16 +119,16 @@ func TestTree_NewTreeFromLeveledListNegativeLevel(t *testing.T) {
 	assert.Empty(t, p.Root)
 }
 
-func TestTree_WithHorizontalString(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithHorizontalString(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithHorizontalString("-")
 
 	assert.Equal(t, "-", p2.HorizontalString)
 	assert.Empty(t, p.HorizontalString)
 }
 
-func TestTree_WithRoot(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithRoot(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithRoot(TreeNode{
 		Children: nil,
 		Text:     "Hello, World!",
@@ -141,8 +141,8 @@ func TestTree_WithRoot(t *testing.T) {
 	assert.Empty(t, p.Root)
 }
 
-func TestTree_WithTreeStyle(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithTreeStyle(t *testing.T) {
+	p := TreePrinter{}
 	s := NewStyle(FgRed, BgRed, Bold)
 	p2 := p.WithTreeStyle(s)
 
@@ -150,8 +150,8 @@ func TestTree_WithTreeStyle(t *testing.T) {
 	assert.Empty(t, p.TreeStyle)
 }
 
-func TestTree_WithTextStyle(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithTextStyle(t *testing.T) {
+	p := TreePrinter{}
 	s := NewStyle(FgRed, BgRed, Bold)
 	p2 := p.WithTextStyle(s)
 
@@ -159,40 +159,40 @@ func TestTree_WithTextStyle(t *testing.T) {
 	assert.Empty(t, p.TextStyle)
 }
 
-func TestTree_WithTopRightCornerString(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithTopRightCornerString(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithTopRightCornerString("-")
 
 	assert.Equal(t, "-", p2.TopRightCornerString)
 	assert.Empty(t, p.TopRightCornerString)
 }
 
-func TestTree_WithTopRightDownStringOngoing(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithTopRightDownStringOngoing(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithTopRightDownStringOngoing("-")
 
 	assert.Equal(t, "-", p2.TopRightDownString)
 	assert.Empty(t, p.TopRightDownString)
 }
 
-func TestTree_WithVerticalString(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithVerticalString(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithVerticalString("-")
 
 	assert.Equal(t, "-", p2.VerticalString)
 	assert.Empty(t, p.VerticalString)
 }
 
-func TestTree_WithIndent(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithIndent(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithIndent(3)
 
 	assert.Equal(t, 3, p2.Indent)
 	assert.Empty(t, p.Indent)
 }
 
-func TestTree_WithIndentInvalid(t *testing.T) {
-	p := Tree{}
+func TestTreePrinter_WithIndentInvalid(t *testing.T) {
+	p := TreePrinter{}
 	p2 := p.WithIndent(0)
 
 	assert.Equal(t, 1, p2.Indent)