Make Highly Customized Boxes for your CLI.

<hr/>
<div align="center">
<img src="img/lib_logo.png" alt="logo">
</div>
<hr/>
 
<div align="center">

[![Go Reference](https://pkg.go.dev/badge/github.com/Delta456/box-cli-maker/v2.svg)](https://pkg.go.dev/github.com/Delta456/box-cli-maker/v2)
[![godocs.io](http://godocs.io/github.com/Delta456/box-cli-maker?status.svg)](https://godocs.io/github.com/Delta456/box-cli-maker/v2)
[![CI](https://github.com/Delta456/box-cli-maker/workflows/Box%20CLI%20Maker/badge.svg)](https://github.com/Delta456/box-cli-maker/actions?query=workflow%3A"Box+CLI+Maker")
[![Go Report Card](https://goreportcard.com/badge/github.com/Delta456/box-cli-maker)](https://goreportcard.com/report/github.com/Delta456/box-cli-maker)
[![GolangCI](https://golangci.com/badges/github.com/moul/golang-repo-template.svg)](https://golangci.com/r/github.com/Delta456/box-cli-maker)
[![GitHub release](https://img.shields.io/github/release/Delta456/box-cli-maker.svg)](https://github.com/Delta456/box-cli-maker/releases)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

</div>

## Features

- Make a Terminal Box in 8️⃣ inbuilt different styles
- 16 Inbuilt Colors and True Color Support 🎨
- Custom Title Positions 📏
- Make your Terminal Box style 📦
- Support for ANSI, Tabbed, Multi-line and Line Wrapping boxes 📑
- Align the text according to your needs 📐
- Unicode, Emoji and [Windows Console](https://en.wikipedia.org/wiki/Windows_Console) Support 😋
- Written in 🇬 🇴

## Installation

```terminal
 go get github.com/Delta456/box-cli-maker/v2
```

## Usage Tutorial

In `main.go`

```go
package main

import "github.com/Delta456/box-cli-maker/v2"

func main() {
 Box := box.New(box.Config{Px: 2, Py: 5, Type: "Single", Color: "Cyan"})
 Box.Print("Box CLI Maker", "Highly Customized Terminal Box Maker")
}
```

`box.New(config Config)` takes Box `Config` and returns a `Box` from the given `Config`.

- Parameters
 - `Px` : Horizontal Padding
 - `Py` : Vertical Padding
 - `ContentAlign` : Content Alignment inside Box i.e. `Center`, `Left` and `Right`
 - `Type`: Box Type
 - `TitlePos` : Title Position of Box i.e. `Inside`, `Top` and `Bottom`
 - `Color` : Box Color
 - `TitleColor` : Title Color
 - `ContentColor` : Content Color
 - `AllowWrapping`: Flag to allow custom `Content` wrapping
 - `WrappingLimit`: Wrap the `Content` up to the Limit

### `Box` Methods

`Box.Print(title, lines string)` prints Box from the specified arguments.

- Parameters
 - `title` : Box Title
 - `lines` : Box Content

`Box.Println(title, lines string)` prints Box in a newline from the specified arguments.

- Parameters
 - `title` : Box Title
 - `lines` : Box Content

`Box.String(title, lines string) string` returns `string` representation of Box.

- Parameters
 - `title` : Box Title
 - `lines` : Box Content

### Box Types

- `Single`


<img src="img/single.svg" alt="single" width=500/>


- `Single Double`


<img src="img/single_double.svg" alt="single_double" width="500"/>


- `Double`


<img src="img/double.svg" alt="double" width="500"/>


- `Double Single`

<img src="img/double_single.svg" alt="double_single" width="500"/>


- `Bold`


<img src="img/bold.svg" alt="bold" width="500"/>


- `Round`


<img src="img/round.svg" alt="round" width="500"/>


- `Hidden`


<img src="img/hidden.svg" alt="hidden" width="500"/>


- `Classic`


<img src="img/classic.svg" alt="classic" width="500"/>


### Title Positions

- `Inside`


<img src="img/single.svg" alt="single" width=500/>


- `Top`


<img src="img/top.svg" alt="top" width=500/>


- `Bottom`


<img src="img/bottom.svg" alt="bottom" width=500/>


### Custom Box

A Custom Box can be created by using the built-in Box struct provided by the module.

```go
type Box struct {
 TopRight string // TopRight Corner Symbols
 TopLeft string // TopLeft Corner Symbols
 Vertical string // Vertical Bar Symbols
 BottomRight string // BottomRight Corner Symbols
 BottomLeft string // BottomLeft Corner Symbols
 Horizontal string // Horizontal Bar Symbols
 Config // Box Config
}
```

#### Usage

In `main.go`:

```go
package main

import "github.com/Delta456/box-cli-maker/v2"

func main() {
 config := box.Config{Px: 2, Py: 3, Type: "", TitlePos: "Inside"}
 boxNew := box.Box{TopRight: "*", TopLeft: "*", BottomRight: "*", BottomLeft: "*", Horizontal: "-", Vertical: "|", Config: config}
 boxNew.Println("Box CLI Maker", "Make Highly Customized Terminal Boxes")
}
```


<img src="img/custom.svg" alt="custom" width=500/>


More examples can be found in the `examples/` folder which you can explore yourself.
Feel free to add more examples and submit a pr for the same.

### Color Types

 The [gookit/color](https://github.com/gookit/color) module provides support for colors in your program. It uses two main types: `FgColor` and `FgHiColor`. These types correspond to different color settings.`Color` is a key for the following maps:

```go
 fgColors map[string]color.Color = {
 "Black": color.FgBlack,
 "Blue": color.FgBlue,
 "Red": color.FgRed,
 "Green": color.FgGreen,
 "Yellow": color.FgYellow,
 "Cyan": color.FgCyan,
 "Magenta": color.FgMagenta,
 "White": color.FgWhite,
}

 fgHiColors map[string]color.Color = {
 "HiBlack": color.FgDarkGray,
 "HiBlue": color.FgLightBlue,
 "HiRed": color.FgLightRed,
 "HiGreen": color.FgLightGreen,
 "HiYellow": color.FgLightYellow,
 "HiCyan": color.FgLightCyan,
 "HiMagenta": color.FgLightMagenta,
 "HiWhite": color.FgLightWhite,
}
```

There are two maps, `fgColors` and `fgHiColors`, which map color names to their respective settings. Here are some examples:

- `fgColors` maps basic colors like Black, Blue, Red, Green, Yellow, Cyan, Magenta, and White.
- `fgHiColors` maps high-intensity colors like HiBlack, HiBlue, HiRed, HiGreen, HiYellow, HiCyan, HiMagenta, and HiWhite.

If you want to use high-intensity colors, make sure the color name starts with "Hi." If the color option is empty or invalid, no color will be applied.

You can also use True Colors by providing them as either a `uint` or `[3]uint`. For `[3]uint`, all elements must be in the range of `[0, 0xFF]`, and for `uint`, it should be in the range of `[0x000000, 0xFFFFFF]`.

If your terminal doesn't support True Colors, the module will automatically round the colors to match the terminal's maximum supported colors. This simplifies things for most users.

If you're curious about supported terminals, you can check the list of 24-bit [supported terminals](https://gist.github.com/XVilka/8346728) and 8-bit [supported terminals](https://fedoraproject.org/wiki/Features/256_Color_Terminals).

Additionally, this module enables True Color and 256 Colors support on Windows Console through [Virtual Terminal Processing](https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences). However, for 256 colors, you need at least [Windows 10 Version 1511](https://en.wikipedia.org/wiki/Windows_10_version_history_(version_1511)), and for True Color support, you need at least [Windows 10 Version 1607](https://en.wikipedia.org/wiki/Windows_10_version_history_(version_1607)).

Finally, if you're using Windows, the module can detect `ConEmu` or `ANSICON` if they're installed. To ensure the best experience, it's recommended to use the latest versions of both programs.

### Content Wrapping

This library allows the usage of custom wrapping of `Content` so that the Box formed will be created according to your own needs.

To use this feature, you need to do two things:

1. Set Config.AllowWrapping to true. This tells the library to allow custom wrapping.

2. Optionally, you can set your own wrapping limit using Config.WrappingLimit. By default, the wrapping limit is set to 2/3 of the current terminal's width (TermWidth).

So, in simple terms, if you want to customize how content is wrapped in boxes, make sure to enable wrapping with Config.AllowWrapping, and if needed, you can adjust the wrapping limit using Config.WrappingLimit, which is initially set to 2/3 of the terminal's width.

### Note

#### 1. Vertical Alignment

As different terminals have different fonts by default, the right vertical alignment may not be aligned well. You will have to change your font accordingly to make it work.

#### 2. Limitations of Unicode and Emoji

Unicode is a character encoding standard that assigns unique codes to characters from various writing systems, allowing universal text representation. 

This library relies on [mattn/go-runewidth](https://github.com/mattn/go-runewidth) to support Unicode and Emoji characters but consider the following:

1. Proper rendering of Unicode and Emojis on Windows is primarily supported by `Windows Terminal`, `ConEmu`, and `Mintty` as terminal emulators. They handle these characters well.

2. Indic text (a script used in some Indian languages) may not display correctly in most terminals. It's important to note that support for Indic text is quite limited.

3. Avoid using this library in certain environments like online code playgrounds such as [`Go Playground`](https://play.golang.org/), [`Repl.it`](https://repl.it), and in Continuous Integration/Continuous Deployment (CI/CD) pipelines. These platforms typically use fonts that only support basic ASCII characters, making it problematic to accurately calculate character lengths when the font changes dynamically.

4. Depending on your font settings, you may need to make adjustments to ensure proper rendering of Unicode and Emoji characters. Failure to do so could result in issues with vertical alignment.

In essence, while this library supports Unicode and Emojis, there are limitations and considerations to keep in mind, especially when dealing with different terminal environments and character sets.

#### 3. Terminal Color Detection

For beginners, this library can adjust True Color to work with your terminal's capabilities, either 8-bit or 4-bit color.

Detecting your terminal's color capacity isn't always straightforward, and there's no universal method. However, if you know a solution for your specific terminal, you can contribute by making a pull request.

For Unix systems:

- If True Color detection fails, you can set the `COLORTERM` environment variable to `truecolor` or `24bit` for True Color support.

- For 8-bit color-based terminals, if detection doesn't work, set the `TERM` environment variable to your terminal emulator's name followed by `256color`, like `xterm-256color`.

Keep in mind that very old terminals like [`Windows Console (Legacy Mode)`](https://docs.microsoft.com/en-us/windows/console/legacymode) or terminals with `TERM` set to `DUMB` might not show color effects, and the module may output unexpected results or warnings.

It's generally not recommended to use this library with color effects in Online Playgrounds, CI/CD environments, Browsers, and similar platforms since color support varies, and detection is challenging. If you encounter issues, you can open an issue and suggest a solution!

#### 4. Tabs

This library supports the usage of tabs but their use should be limited.

### Projects using Box CLI Maker

- <img src="img\k8s_logo.png" alt="kubernetes logo" width="20"> [kubernetes/minikube](https://github.com/kubernetes/minikube): Run Kubernetes locally.
- +[Many More](https://pkg.go.dev/github.com/Delta456/box-cli-maker/v2?tab=importedby)!

### Acknowledgements

I thank the following people and their packages whom I have studied and was able to port to Go accordingly.

- [thecodrr/boxx](https://github.com/thecodrr/boxx)
- [Atrox/box](https://github.com/Atrox/box)
- [sindreorhus-cli-boxes](https://github.com/sindresorhus/cli-boxes)

Also special thanks to [@elimsteve](https://github.com/elimisteve) who helped me to optimize the code and told me the best possible ways to fix my problems, [@JalonSolov](https://github.com/JalonSolov) for tab lines support and [Kunal Raghav](https://github.com/KunalRaghav) for making the library's logo.

Kudos to [moul/golang-repo-template](https://github.com/moul/golang-repo-template) for their Go template.

### License

Licensed under [MIT](LICENSE)

box-cli-maker

Contextual fmt inspired by bootstrap color classes.

<h1 align="center">Cfmt</h1>


 <a href="/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
 <a href="https://godoc.org/github.com/mingrammer/cfmt"><img src="https://godoc.org/github.com/mingrammer/cfmt?status.svg"/>
 <a href="https://goreportcard.com/report/github.com/mingrammer/cfmt"><img src="https://goreportcard.com/badge/github.com/mingrammer/cfmt"/></a>
</a>
 <a href="https://travis-ci.org/mingrammer/cfmt"><img src="https://travis-ci.org/mingrammer/cfmt.svg?branch=master"/></a>
 <a href="https://codecov.io/gh/mingrammer/cfmt"><img src="https://codecov.io/gh/mingrammer/cfmt/branch/master/graph/badge.svg"/></a>


 Contextual fmt 

 

It provides contextual formatting functions that have nearly identical usage of the fmt package. The ideas were borrowed from bootstrap's contextual color classes.

## Installation

```
go get github.com/mingrammer/cfmt
```

## Usage

```go
package main

import (
 "log"

 "github.com/mingrammer/cfmt"
)

func main() {
 cfmt.Success("User was created successfully")
 cfmt.Infoln("Here are some candidates")
 cfmt.Warningf("%s is not valid integer value\n", "123a")
 log.Fatal(cfmt.Serrorf("Only numeric is allowed, got %s", "123.456a"))
}
```

![cfmt output](images/output.png)

## Contextual functions

> Note: cfmt.Errorf function does not do same things to fmt.Errorf, but to fmt.Printf with red colored text.

- Success (Green)
 - Fsuccess, Fsuccessf, Fsuccessln
 - Success, Successf, Successln
 - Ssuccess, Ssuccessf, Ssuccessln
- Info (Cyan)
 - Finfo, Finfof, Finfoln
 - Info, Infof, Infoln
 - Sinfo, Sinfof, Sinfoln
- Warning (Yellow)
 - Fwarning, Fwarningf, Fwarningln
 - Warning, Warningf, Warningln
 - Swarning, Swarningf, Swarningln
- Error (Red)
 - Ferror, Ferrorf, Ferrorln
 - Error, Errorf, Errorln
 - Serror, Serrorf, Serrorln

## License

MIT

cfmt

Simple and convenient formatted stylized output fully compatible with fmt library.

![](doc/logo.png)

[![Build Status](https://travis-ci.org/i582/cfmt.svg?branch=master)](https://travis-ci.org/i582/cfmt) [![Codecov](https://codecov.io/gh/i582/cfmt/branch/master/graph/badge.svg)](https://codecov.io/gh/i582/cfmt) [![Go Report Card](https://goreportcard.com/badge/github.com/i582/cfmt)](https://goreportcard.com/report/github.com/i582/cfmt) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/i582/phpstats/master/LICENSE) ![](https://img.shields.io/badge/-%3C%3E%20with%20%E2%9D%A4-red) [![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

# cfmt

**cfmt** is a small library for **simple and convenient formatted stylized output** to the console, providing an interface that is exactly the same as the standard `fmt` and `log` libraries.

## Table of Contents

* [Install](#install)
* [Usage](#usage)
 * [Simple usage](#simple-usage)
 * [Complex style](#complex-style)
 * [Custom styles](#custom-styles)
 * [HEX colors](#hex-colors)
 * [Background color](#background-color)
* [Other examples](#other-examples)
* [Supported colors and styles](#supported-colors-and-styles)
* [Motivation](#motivation)
* [Contact](#contact)
* [License](#license)

## Install

```
go get -v github.com/i582/cfmt
```

## Usage

To switch to `cfmt` anywhere in the code, it is enough to add one letter `c` to `fmt` (or to `log`), import the required part (`cfmt` or `clog`):

```go
import (
	"github.com/i582/cfmt/cmd/cfmt"
	// or
	"github.com/i582/cfmt/cmd/clog"
)
```

and you get all the possibilities, the library is fully compatible with the standard libraries `fmt` and `log`

### Simple usage

Let's take an example:

Suppose you need to display text and highlight some word or phrase. Using `cfmt`, all that is needed is to wrap the desired part in `{{}}` and after `::` write the desired styles:

```go
cfmt.Println("This is a {{red color}}::red")
```

![](doc/example1.svg)

If we compare this with the `gookit/color` library, then this example looks more complicated and less readable there:

```go
fmt.Printf("This is a %s", color.Red.Sprintf("red color"))
```

### Complex style

It is even more convenient if you need complex styles, if you want to make the text also bold, then all you need to add is in the format after `|` write `bold`:

```go
cfmt.Println("This is a {{red color}}::red|bold")
```

![](doc/example2.svg)

In `gookit/color`, this is done as follows:

```go
redBold := color.New(color.FgRed, color.OpBold)
fmt.Printf("This is a %s", redBold.Sprintf("red color"))
```

### Custom styles

In the `gookit/color` we can reuse the created style, in ` cfmt` this is also possible. To do this, you need to register a new style using the `cfmt.RegisterStyle` function:

```go
cfmt.RegisterStyle("code", func(s string) string {
	return cfmt.Sprintf("{{%s}}::red|underline", s)
})
```

And now it can be used anywhere just by writing its name:

```go
cfmt.Println("This is a {{red color}}::code")
```

![](doc/example3.svg)

The new style can of course also be used in conjunction with others:

```go
cfmt.Println("This is a {{red color}}::code|bold")
```

![](doc/example4.svg)

Also you can do whatever you want with the text, which is styled.

```go
cfmt.RegisterStyle("flag", func(s string) string {
 return cfmt.Sprintf("{{--%s}}::green (-%c)", s, s[0])
})
```

```go
flag := "help"
cfmt.Println("{{%s}}::flag ", flag)
```

![](doc/example8.svg)

### HEX colors

If the standard colors are not enough for you, then you can use the colors in the `HEX` format (*NOTE: not all terminals support all colors fully!*).

```go
cfmt.Println("This is a {{red color}}::#ff0000")
```

### Background color

To set the background color, you need to add the prefix `bg` to the color, in the case of standard colors, the first letter of the color must be capitalized:

```go
cfmt.Println("This is a {{red color}}::bgRed")
```

For `HEX` it will look like this:

```go
cfmt.Println("This is a {{red color}}::bg#ff0000")
```

## Other examples

```go
cfmt.RegisterStyle("code", func(s string) string {
	return cfmt.Sprintf("{{%s}}::red|underline", s)
})

cfmt.Printf(`
 {{Example of reports}}::bold

 {{ }}::bgRed
 {{ Critical errors found }}::bgRed|#ffffff
 {{ }}::bgRed

 {{100}}::#ffffff myStyle := color.{{New(color.FgWhite, color.BgBlack, color.OpBold)}}::code|bold
 {{[100, 17]}}::blue Undefined function New at {{~/projects/test}}::underline:100

 {{101}}::#ffffff {{myStyle}}::code.Print("t")
 {{[101, 0]}}::blue Undefined variable myStyle at {{~/projects/test}}::underline:101
`)
```

![](doc/example6.png)

```go
cfmt.Print(`
 {{ -/+:. }}::green
 {{ :++++. }}::green
 {{ /+++/. }}::green
 {{ .:-::- .+/:-''.::- }}::green
 {{ .:/++++++/::::/++++++//: }}::green
 {{ .:///////////////////////: }}::yellow
 {{ //////////////////////// }}::yellow
 {{ -+++++++++++++++++++++++ }}::red
 {{ /++++++++++++++++++++++/ }}::red
 {{ /sssssssssssssssssssssss. }}::red
 {{ :ssssssssssssssssssssssss- }}::red
 {{ osssssssssssssssssssssssso/ }}::magenta
 {{ syyyyyyyyyyyyyyyyyyyyyyyy+ }}::magenta
 {{ ossssssssssssssssssssss/ }}::blue
 {{ :ooooooooooooooooooo+. }}::blue
 {{ :+oo+/:-..-:/+o+/- }}::blue
`)
```

![](doc/example7.svg)

## Supported colors and styles

| Styles |
| -------------------- |
| *italic* |
| **bold** |
| ~~crossout~~ |
| <ins>underline</ins> |
| concealed |
| reverse |
| blink |


| Colors | | | |
| ------- | ------------ | ------------- | --------- |
| black | darkGray | bgDarkGray | bgBlack |
| red | lightRed | bgLightRed | bgRed |
| green | lightGreen | bgLightGreen | bgGreen |
| yellow | lightYellow | bgLightYellow | bgYellow |
| blue | lightBlue | bgLightBlue | bgBlue |
| magenta | lightMagenta | bgLightMagent | bgMagenta |
| cyan | lightCyan | bgLightCyan | bgCyan |
| white | lightWhite | bgLightWhite | bgWhite |
| gray | | | bgGray |

And colors in HEX format. See [HEX colors](#hex-colors) part.

## Motivation

The existing libraries for styling the output are very powerful and this library builds on one of them ([gookit/color](https://github.com/gookit/color)). However, they are not very useful for styling certain words or sentences, since you need to use `Sprintf` and put the styled ones in a format string, which greatly reduces readability if you need to style many elements.

I believe that the library will be useful primarily for formatting ready-made text, for reference, or examples. However, in other cases, it should be just as convenient.

The library aims to make formatted text look readable in code, even with complex formatting.

## Contact

 For any questions — tg: `@petr_makhnev`.

## License

This project is under the **MIT License**. See the [LICENSE](https://github.com/i582/phpstats/blob/master/LICENSE) file for the full license text.

Intuitive package for prettifying terminal/console output.

chalk
=============

Chalk is a go package for styling console/terminal output.

Check out godoc for some example usage:
http://godoc.org/github.com/ttacon/chalk

The api is pretty clean, there are default Colors and TextStyles
which can be mixed to create more intense Styles. Styles and Colors
can be printed in normal strings (i.e. ```fmt.Sprintf(chalk.Red)```), but
Styles, Colors and TextStyles are more meant to be used to style specific
text segments (i.e. ```fmt.Println(chalk.Red.Color("this is red")```) or
```fmt.Println(myStyle.Style("this is blue text that is underlined"))```).

Examples
=============

There are a few examples in the examples directory if you want to see a very
simplified version of what you can do with chalk.

The following code:
```go
package main

import (
	"fmt"

	"github.com/ttacon/chalk"
)

func main() {
	// You can just use colors
	fmt.Println(chalk.Red, "Writing in colors", chalk.Cyan, "is so much fun", chalk.Reset)
	fmt.Println(chalk.Magenta.Color("You can use colors to color specific phrases"))

	// You can just use text styles
	fmt.Println(chalk.Bold.TextStyle("We can have bold text"))
	fmt.Println(chalk.Underline.TextStyle("We can have underlined text"))
	fmt.Println(chalk.Bold, "But text styles don't work quite like colors :(")

	// Or you can use styles
	blueOnWhite := chalk.Blue.NewStyle().WithBackground(chalk.White)
	fmt.Printf("%s%s%s\n", blueOnWhite, "And they also have backgrounds!", chalk.Reset)
	fmt.Println(
		blueOnWhite.Style("You can style strings the same way you can color them!"))
	fmt.Println(
		blueOnWhite.WithTextStyle(chalk.Bold).
			Style("You can mix text styles with colors, too!"))

	// You can also easily make styling functions thanks to go's functional side
	lime := chalk.Green.NewStyle().
		WithBackground(chalk.Black).
		WithTextStyle(chalk.Bold).
		Style
	fmt.Println(lime("look at this cool lime text!"))
}

```
Outputs
![screenshot](https://raw.githubusercontent.com/ttacon/chalk/master/img/chalk_example.png)


WARNING
=============

This package should be pretty stable (I don't forsee backwards incompatible changes), but I'm not making any promises :)


chalk

Go library for ANSI colour text in terminals.

# colourize
[![GoDoc](https://godoc.org/github.com/TreyBastian/colourize?status.svg)](https://godoc.org/github.com/TreyBastian/colourize) [![Build Status](https://travis-ci.org/TreyBastian/colourize.svg?branch=master)](https://travis-ci.org/TreyBastian/colourize) [![Coverage Status](https://coveralls.io/repos/TreyBastian/colourize/badge.svg?branch=master)](https://coveralls.io/r/TreyBastian/colourize?branch=master) [![Go Report
Card](https://goreportcard.com/badge/github.com/TreyBastian/colourize)](https://goreportcard.com/report/github.com/TreyBastian/colourize)

An ANSI colour terminal package for Go.
Supports all ANSI colours and emphasis. Not compatible with Windows systems.

# Project is no longer maintained.
This project is no longer maintained. However it's also complete. It has not and will not be updated with new Go features.

# Installation

     go get github.com/TreyBastian/colourize 

# Usage

    package main
    import (
        c "github.com/TreyBastian/colourize"
        "fmt"
    )
    
    func main() {
      fmt.Println(c.Colourize("Hello World!", c.Green, c.Whitebg, c.Bold))
    }


# Projects Using colourize
*  [nettee](https://github.com/Manaphy91/nettee)


colourize

Print ASCII tables from command line utilities without the need to pass large sets of data to the API.

[![LICENSE](https://img.shields.io/badge/license-MIT-orange.svg)](LICENSE)
[![Build Status](https://travis-ci.org/InVisionApp/tabular.svg?branch=master)](https://travis-ci.org/InVisionApp/tabular)
[![codecov](https://codecov.io/gh/InVisionApp/tabular/branch/master/graph/badge.svg)](https://codecov.io/gh/InVisionApp/tabular)
[![Go Report Card](https://goreportcard.com/badge/github.com/InVisionApp/tabular)](https://goreportcard.com/report/github.com/InVisionApp/tabular)
[![Godocs](https://img.shields.io/badge/golang-documentation-blue.svg)](https://godoc.org/github.com/InVisionApp/tabular)

# tabular

Tabular simplifies printing ASCII tables from command line utilities without the need to pass large sets of data to it's API.  

Simply define the table columns and `tabular` will parse the right [format specifier](https://golang.org/pkg/fmt/#Printf) that you can use in your calls to `fmt.Printf()` or any other function that supports it.

Table columns can be defined once and then reused over and over again making it easy to modify column length and heading in one place.  And a subset of columns can be specified during `tabular.Print()` or `tabular.Parse()` calls to modify the table's title without redefining it.

Example (also available in [`example/example.go`](example/example.go)):

```go
package main

import (
	"fmt"
	"log"

	"github.com/InVisionApp/tabular"
)

var tab tabular.Table

func init() {
	tab = tabular.New()
	tab.Col("env", "Environment", 14)
	tab.Col("cls", "Cluster", 10)
	tab.Col("svc", "Service", 15)
	tab.Col("hst", "Database Host", 20)
	tab.ColRJ("pct", "%CPU", 7)
}

var data = []struct {
	e, c, s, d string
	v          float64
}{
	{
		e: "production",
		c: "cluster-1",
		s: "service-a",
		d: "database-host-1",
		v: 70.01,
	},
	{
		e: "production",
		c: "cluster-1",
		s: "service-b",
		d: "database-host-2",
		v: 99.51,
	},
	{
		e: "production",
		c: "cluster-2",
		s: "service-a",
		d: "database-host-1",
		v: 70.01,
	},
	{
		e: "production",
		c: "cluster-2",
		s: "service-b",
		d: "database-host-2",
		v: 99.51,
	},
}

func main() {
	// Print a subset of columns (Environments and Clusters)
	format := tab.Print("env", "cls")
	for _, x := range data {
		fmt.Printf(format, x.e, x.c)
	}

	// Print All Columns
	format = tab.Print("*")
	for _, x := range data {
		fmt.Printf(format, x.e, x.c, x.s, x.d, x.v)
	}

	// Print All Columns to a custom destination such as a log
	table := tab.Parse("*")
	log.Println(table.Header)
	log.Println(table.SubHeader)
	for _, x := range data {
		log.Printf(table.Format, x.e, x.c, x.s, x.d, x.v)
	}
}
```

Produces:

```
Environment    Cluster
-------------- ----------
production     cluster-1
production     cluster-1
production     cluster-2
production     cluster-2

Environment    Cluster    Service         Database Host           %CPU
-------------- ---------- --------------- -------------------- -------
production     cluster-1  service-a       database-host-1        70.01
production     cluster-1  service-b       database-host-2        99.51
production     cluster-2  service-a       database-host-1        70.01
production     cluster-2  service-b       database-host-2        99.51

2018/05/14 11:19:41 Environment    Cluster    Service         Database Host           %CPU
2018/05/14 11:19:41 -------------- ---------- --------------- -------------------- -------
2018/05/14 11:19:41 production     cluster-1  service-a       database-host-1        70.01
2018/05/14 11:19:41 production     cluster-1  service-b       database-host-2        99.51
2018/05/14 11:19:41 production     cluster-2  service-a       database-host-1        70.01
2018/05/14 11:19:41 production     cluster-2  service-b       database-host-2        99.51
```

The Best Go Libraries For Command Line - Libraries for building Console Applications and Console User Interfaces. (6)

box-cli-maker

cfmt

cfmt

chalk

colourize

tabular