Module format
This commit is contained in:
Benjamin VAUDOUR
parent
0a1722dd44
commit
34cb5b19ca
|
|
@ -0,0 +1,156 @@
|
|||
package format
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// Tab crée une tabulation d’une longueur donnée.
|
||||
func Tab(size int) string {
|
||||
return strings.Repeat(" ", size)
|
||||
}
|
||||
|
||||
// TabulateLeft ajoute <tabsize> espaces à gauche.
|
||||
func TabulateLeft(str string, tabSize int) string {
|
||||
return Tab(tabSize) + str
|
||||
}
|
||||
|
||||
// TabulateRight ajoute <tabsize> espaces à droite.
|
||||
func TabulateRight(str string, tabSize int) string {
|
||||
return str + Tab(tabSize)
|
||||
}
|
||||
|
||||
// Tabulate ajoute <leftSize> espaces à gauche et <rightSize> espaces à droite.
|
||||
func Tabulate(str string, leftSize, rightSize int) string {
|
||||
return Tab(leftSize) + str + Tab(rightSize)
|
||||
}
|
||||
|
||||
// AlignmentType représente un type d’alignement.
|
||||
type AlignmentType int
|
||||
|
||||
const (
|
||||
LEFT AlignmentType = iota
|
||||
RIGHT
|
||||
CENTER
|
||||
)
|
||||
|
||||
// Alignment permet d’aligner des chaînes selon des caractérisques prédéfinies.
|
||||
type Alignment struct {
|
||||
t AlignmentType
|
||||
l int
|
||||
}
|
||||
|
||||
// NewAlignement retourne un aligneur de type t (gauche, droit ou centré) et de longueur définie.
|
||||
// Ainsi un aligneur gauche défini à 10 caractères transformera une chaîne de la façon suivante :
|
||||
// - si la chaîne fait plus de 10 caractères, elle est tronquée à droite
|
||||
// - sinon, des espaces sont rajoutées à droite de sorte que la chaîne de sortie fasse 10 caractères.
|
||||
// Un aligneur droit procède de la même manière mais de l’autre côté.
|
||||
// Un aligneur centré équilibre de sorte que la chaîne d’entrée reste au milieu.
|
||||
func NewAlignment(t AlignmentType, size int) Alignment {
|
||||
if size <= 0 {
|
||||
panic("Size of alignment must be positive")
|
||||
}
|
||||
|
||||
return Alignment{
|
||||
t: t,
|
||||
l: size,
|
||||
}
|
||||
}
|
||||
|
||||
func size(str string) int { return utf8.RuneCountInString(str) }
|
||||
|
||||
// Formate aligne la chaîne d’entrée selon les paramètres
|
||||
// prédéfinis de l’aligneur.
|
||||
func (a Alignment) Format(str string) string {
|
||||
l := size(str)
|
||||
if l == a.l {
|
||||
return str
|
||||
}
|
||||
d := a.l - l
|
||||
runes := []rune(str)
|
||||
switch a.t {
|
||||
case RIGHT:
|
||||
if d > 0 {
|
||||
return TabulateLeft(str, d)
|
||||
}
|
||||
return string(runes[-d:])
|
||||
case CENTER:
|
||||
if d > 0 {
|
||||
left := d >> 1
|
||||
right := d - left
|
||||
return Tabulate(str, left, right)
|
||||
}
|
||||
left := (-d) >> 1
|
||||
return string(runes[left : left+a.l])
|
||||
default:
|
||||
if d > 0 {
|
||||
return TabulateRight(str, d)
|
||||
}
|
||||
return string(runes[:a.l])
|
||||
}
|
||||
}
|
||||
|
||||
// Align align la chaîne selon le type d’alignement donné,
|
||||
// de sorte que la chaîne de sortie ait la longueur spécifiée.
|
||||
func Align(str string, align AlignmentType, size int) string {
|
||||
a := NewAlignment(align, size)
|
||||
|
||||
return a.Format(str)
|
||||
}
|
||||
|
||||
// Left aligne à gauche.
|
||||
func Left(str string, size int) string {
|
||||
return Align(str, LEFT, size)
|
||||
}
|
||||
|
||||
// Right aligne à droite.
|
||||
func Right(str string, size int) string {
|
||||
return Align(str, RIGHT, size)
|
||||
}
|
||||
|
||||
// Center centre la chaîne.
|
||||
func Center(str string, size int) string {
|
||||
return Align(str, CENTER, size)
|
||||
}
|
||||
|
||||
// ColumnSet permet de formater les entrées d’un tableau.
|
||||
// Chaque entrée correspond à un aligneur de colonne.
|
||||
type ColumnSet []Alignment
|
||||
|
||||
// NewColumnSet retourne un formateur de tableaux.
|
||||
func NewColumnSet(aligns ...Alignment) ColumnSet {
|
||||
return aligns
|
||||
}
|
||||
|
||||
// Normalize formate les colonnes spcéfiées en entrées.
|
||||
// Le nombre de colonnes doit être identique au nombre de l’aligneurs
|
||||
// du formateur de colonnes.
|
||||
func (cs ColumnSet) Normalize(columns []string) (out []string) {
|
||||
if len(cs) != len(columns) {
|
||||
panic("Number of columns must be equal to number of column set")
|
||||
}
|
||||
|
||||
out = make([]string, len(columns))
|
||||
for i, a := range cs {
|
||||
out[i] = a.Format(columns[i])
|
||||
}
|
||||
|
||||
return out
|
||||
}
|
||||
|
||||
// Line formate une ligne de tableau, avec :
|
||||
// - columns : liste des colonnes de la ligne
|
||||
// - sep : séparateur de colonnes
|
||||
// - prefix : préfixe de ligne
|
||||
// - suffix : suffixe de ligne
|
||||
func (cs ColumnSet) Line(columns []string, sep, prefix, suffix string) string {
|
||||
out := cs.Normalize(columns)
|
||||
|
||||
if prefix != "" || suffix != "" {
|
||||
for i, c := range out {
|
||||
out[i] = prefix + c + suffix
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(out, sep)
|
||||
}
|
||||
|
|
@ -0,0 +1,222 @@
|
|||
package format
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
. "gitea.zaclys.com/bvaudour/gob/option"
|
||||
)
|
||||
|
||||
// Color permet de colorer une chaîne dans un terminal de type UNIX.
|
||||
type Color struct {
|
||||
Option[int]
|
||||
}
|
||||
|
||||
const (
|
||||
black int = iota
|
||||
red
|
||||
green
|
||||
yellow
|
||||
blue
|
||||
majenta
|
||||
cyan
|
||||
white
|
||||
|
||||
light = 1 << 3
|
||||
background = 1 << 4
|
||||
dark = ^light
|
||||
foreground = ^dark
|
||||
)
|
||||
|
||||
var colors = map[string]int{
|
||||
"black": black,
|
||||
"red": red,
|
||||
"green": green,
|
||||
"yellow": yellow,
|
||||
"blue": blue,
|
||||
"majenta": majenta,
|
||||
"cyan": cyan,
|
||||
"white": white,
|
||||
}
|
||||
|
||||
var prefixes = []string{
|
||||
"fg_l_",
|
||||
"fg_",
|
||||
"l_",
|
||||
"bg_l_",
|
||||
"bg_",
|
||||
}
|
||||
|
||||
var prefixFuncs = map[string]func(string) Color{
|
||||
"fg_l_": fgLightColor,
|
||||
"fg_": fgColor,
|
||||
"l_": fgLightColor,
|
||||
"bg_l_": bgLightColor,
|
||||
"bg_": bgColor,
|
||||
}
|
||||
|
||||
// IsLight retourne vrai si la couleur est claire.
|
||||
func (c Color) IsLight() bool {
|
||||
v, ok := c.Get()
|
||||
return ok && v&light != 0
|
||||
}
|
||||
|
||||
// IsDark retourne vrai si la couleur est foncée.
|
||||
func (c Color) IsDark() bool {
|
||||
v, ok := c.Get()
|
||||
return ok && v&light == 0
|
||||
}
|
||||
|
||||
// IsBackground retourne vrai si c’est une couleur d’arrière-plan.
|
||||
func (c Color) IsBackground() bool {
|
||||
v, ok := c.Get()
|
||||
return ok && v&background != 0
|
||||
}
|
||||
|
||||
// IsForeground retourne vrai si c’est une couleur de police.
|
||||
func (c Color) IsForeground() bool {
|
||||
v, ok := c.Get()
|
||||
return ok && v&background == 0
|
||||
}
|
||||
|
||||
// Light retourne l’équivalent clair de la couleur.
|
||||
func (c Color) Light() Color {
|
||||
if v, ok := c.Get(); ok {
|
||||
return Color{Some(v | light)}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Dark retourne l’équivalent foncé de la couleur.
|
||||
func (c Color) Dark() Color {
|
||||
if v, ok := c.Get(); ok {
|
||||
return Color{Some(v & dark)}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Background retourne la couleur équivalente d’arrière-plan.
|
||||
func (c Color) Background() Color {
|
||||
if v, ok := c.Get(); ok {
|
||||
return Color{Some(v | background)}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Foreground retourne la couleur équivalente de police.
|
||||
func (c Color) Foreground() Color {
|
||||
if v, ok := c.Get(); ok {
|
||||
return Color{Some(v & foreground)}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Color retourne la composante couleur de base de la couleur.
|
||||
func (c Color) Color() Color {
|
||||
if v, ok := c.Get(); ok {
|
||||
return Color{Some(v & white)}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Color retourne la composante couleur foncée/claire de la couleur .
|
||||
func (c Color) Base() Option[int] {
|
||||
v, ok := c.Get()
|
||||
if !ok {
|
||||
return None[int]()
|
||||
}
|
||||
b := 30 + (v & white)
|
||||
if c.IsBackground() {
|
||||
b += 10
|
||||
}
|
||||
if c.IsLight() {
|
||||
b += 60
|
||||
}
|
||||
|
||||
return Some(b)
|
||||
}
|
||||
|
||||
// String retourne la valeur d’échappement ASCII de la couleur.
|
||||
func (c Color) String(force ...bool) string {
|
||||
b, ok := c.Base().Get()
|
||||
if !ok {
|
||||
return ""
|
||||
}
|
||||
s := fmt.Sprint(b)
|
||||
if len(force) > 0 && force[0] && !c.IsLight() && !c.IsBackground() {
|
||||
s = "2;" + s
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// Format colore la chaîne donnée selon la couleur spécifiée.
|
||||
func (c Color) Format(text string) string {
|
||||
if !c.IsDefined() {
|
||||
return text
|
||||
}
|
||||
return fmt.Sprintf(formatTpl, c.String(), text)
|
||||
}
|
||||
|
||||
func colorOf(name string) (c Color) {
|
||||
if v, ok := colors[name]; ok {
|
||||
c = Color{Some(v)}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func fgDarkColor(name string) Color {
|
||||
return colorOf(name)
|
||||
}
|
||||
|
||||
func fgLightColor(name string) (c Color) {
|
||||
return colorOf(name).Light()
|
||||
}
|
||||
|
||||
func fgColor(name string) Color {
|
||||
if strings.HasPrefix(name, "l_") {
|
||||
n := strings.TrimPrefix(name, "l_")
|
||||
return fgLightColor(n)
|
||||
}
|
||||
return fgDarkColor(name)
|
||||
}
|
||||
|
||||
func bgDarkColor(name string) Color {
|
||||
return colorOf(name).Background()
|
||||
}
|
||||
|
||||
func bgLightColor(name string) (c Color) {
|
||||
return colorOf(name).Background().Light()
|
||||
}
|
||||
|
||||
func bgColor(name string) Color {
|
||||
if strings.HasPrefix(name, "l_") {
|
||||
n := strings.TrimPrefix(name, "l_")
|
||||
return bgLightColor(n)
|
||||
}
|
||||
return bgDarkColor(name)
|
||||
}
|
||||
|
||||
// ColorOf retourne la couleur au nom demandé.
|
||||
// Les noms possibles sont :
|
||||
// - white
|
||||
// - black
|
||||
// - red
|
||||
// - green
|
||||
// - blue
|
||||
// - yellow
|
||||
// - magenta
|
||||
// - cyan
|
||||
// Le préfixe l_ peut être rajouté à la couleur pour forcer le mode clair.
|
||||
// Le préfixe bg_ ou fg_ peut être ajouté pour forcer, respectivement la couleur
|
||||
// d’arrière-plan ou de police (mode par défaut).
|
||||
func ColorOf(name string) Color {
|
||||
for _, prefix := range prefixes {
|
||||
if strings.HasPrefix(name, prefix) {
|
||||
n := strings.TrimPrefix(name, prefix)
|
||||
return prefixFuncs[prefix](n)
|
||||
}
|
||||
}
|
||||
|
||||
return colorOf(name)
|
||||
}
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
package format
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"gitea.zaclys.com/bvaudour/gob/collection"
|
||||
)
|
||||
|
||||
const formatTpl = "\033[%sm%s\033[m"
|
||||
|
||||
// Format permet d’appliquer des styles et des couleurs à des chaînes dans un terminal de type UNIX.
|
||||
type Format struct {
|
||||
fg Color
|
||||
bg Color
|
||||
styles []Style
|
||||
}
|
||||
|
||||
// Background retourne la couleur d’arrière-plan.
|
||||
func (f Format) Background() Color {
|
||||
return f.bg
|
||||
}
|
||||
|
||||
// Foreground retourne la couleur de police.
|
||||
func (f Format) Foreground() Color {
|
||||
return f.fg
|
||||
}
|
||||
|
||||
// Styles retourne les styles appliqués.
|
||||
func (f Format) Styles() []Style {
|
||||
out := make([]Style, len(f.styles))
|
||||
copy(out, f.styles)
|
||||
|
||||
return out
|
||||
}
|
||||
|
||||
// SetBg définit la couleur d’arrière-plan au formateur.
|
||||
func (f *Format) SetBg(c Color) Format {
|
||||
if !c.IsForeground() {
|
||||
f.bg = c
|
||||
}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// RemoveBg supprime la couleur d’arrière-plan du formatteur.
|
||||
func (f *Format) RemoveBg() Format {
|
||||
return f.SetBg(Color{})
|
||||
}
|
||||
|
||||
// SetFg définit la couleur de police du formateur.
|
||||
func (f *Format) SetFg(c Color) Format {
|
||||
if !c.IsBackground() {
|
||||
f.fg = c
|
||||
}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// RemoveFg supprime la couleur de police du formateur.
|
||||
func (f *Format) RemoveFg() Format {
|
||||
return f.SetFg(Color{})
|
||||
}
|
||||
|
||||
// SetColor ajoute la couleur au formateur (arrière-plan ou police).
|
||||
func (f *Format) SetColor(c Color) Format {
|
||||
if c.IsBackground() {
|
||||
return f.SetBg(c)
|
||||
} else if c.IsForeground() {
|
||||
return f.SetFg(c)
|
||||
}
|
||||
return *f
|
||||
}
|
||||
|
||||
// AddStyles ajoute des styles au formateur.
|
||||
func (f *Format) AddStyles(st ...Style) Format {
|
||||
for _, s := range st {
|
||||
if s.IsDefined() {
|
||||
f.styles = append(f.styles, s)
|
||||
}
|
||||
}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// RemoveStyles supprime les styles du formateur.
|
||||
func (f *Format) RemoveStyles(st ...Style) Format {
|
||||
f.styles = collection.Diff(f.styles, st)
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// Push ajoute des styles et des couleurs au formateur selon les noms donnés.
|
||||
// Pour plus de détail, lire la documentation sur StyleOf et ColorOf.
|
||||
func (f *Format) Push(names ...string) Format {
|
||||
for _, n := range names {
|
||||
if st := StyleOf(n); st.IsDefined() {
|
||||
f.AddStyles(st)
|
||||
} else if c := ColorOf(n); c.IsDefined() {
|
||||
f.SetColor(c)
|
||||
}
|
||||
}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// Pop supprime les styles et les couleurs selon les noms donnés.
|
||||
// Pour plus de détail, lire la documentation sur StyleOf et ColorOf.
|
||||
func (f *Format) Pop(names ...string) Format {
|
||||
for _, n := range names {
|
||||
if st := StyleOf(n); st.IsDefined() {
|
||||
f.RemoveStyles(st)
|
||||
} else if c := ColorOf(n); c.IsDefined() {
|
||||
if c.IsBackground() {
|
||||
f.RemoveBg()
|
||||
} else {
|
||||
f.RemoveFg()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// Reset réinitialise le formateur.
|
||||
func (f *Format) Reset() Format {
|
||||
f.fg = Color{}
|
||||
f.bg = Color{}
|
||||
f.styles = []Style{}
|
||||
|
||||
return *f
|
||||
}
|
||||
|
||||
// String retourne la chaîne d’échappement ASCII du formateur.
|
||||
func (f Format) String() string {
|
||||
var args []string
|
||||
var is_bold bool
|
||||
|
||||
for _, s := range f.styles {
|
||||
args = append(args, s.String())
|
||||
if s.IsNormal() || (s.IsBold() && s.IsCancel()) {
|
||||
is_bold = false
|
||||
} else if s.IsBold() {
|
||||
is_bold = true
|
||||
}
|
||||
}
|
||||
if f.fg.IsDefined() {
|
||||
args = append(args, f.fg.String(is_bold))
|
||||
}
|
||||
if f.bg.IsDefined() {
|
||||
args = append(args, f.bg.String())
|
||||
}
|
||||
|
||||
return strings.Join(args, ";")
|
||||
}
|
||||
|
||||
// Format formate le texte selon la configuration du formateur.
|
||||
func (f Format) Format(text string) string {
|
||||
return fmt.Sprintf(formatTpl, f, text)
|
||||
}
|
||||
|
||||
// FormatOf retourne un formateur selon les noms de styles et de couleurs à appliquer.
|
||||
func FormatOf(formats ...string) (f Format) {
|
||||
return f.Push(formats...)
|
||||
}
|
||||
|
||||
// Apply formate le texte donné avec les styles/couleurs donnés (par nom).
|
||||
func Apply(text string, formats ...string) string {
|
||||
return FormatOf(formats...).Format(text)
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
package format
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
. "gitea.zaclys.com/bvaudour/gob/option"
|
||||
)
|
||||
|
||||
// Style permet de définir un style à une chaîne dans un terminal de type UNIX.
|
||||
type Style struct {
|
||||
Option[int]
|
||||
}
|
||||
|
||||
const (
|
||||
normal int = 0
|
||||
bold int = 1
|
||||
italic int = 3
|
||||
underline int = 4
|
||||
blink int = 5
|
||||
inverted int = 7
|
||||
crossed int = 9
|
||||
cancel int = 20
|
||||
)
|
||||
|
||||
var styles = map[string]int{
|
||||
"normal": normal,
|
||||
"bold": bold,
|
||||
"italic": italic,
|
||||
"underline": underline,
|
||||
"blink": blink,
|
||||
"inverted": inverted,
|
||||
"crossed": crossed,
|
||||
"!bold": cancel + bold,
|
||||
"!italic": cancel + italic,
|
||||
"!underline": cancel + underline,
|
||||
"!blink": cancel + blink,
|
||||
"!inverted": cancel + inverted,
|
||||
"!crossed": cancel + crossed,
|
||||
}
|
||||
|
||||
// IsCancel retourne vrai si le style est une annulation de style.
|
||||
func (st Style) IsCancel() bool {
|
||||
v, ok := st.Get()
|
||||
return ok && v >= 20
|
||||
}
|
||||
|
||||
// IsBold retourne vrai si le style de de type gras.
|
||||
func (st Style) IsBold() bool {
|
||||
v, ok := st.Get()
|
||||
return ok && v|bold != 0
|
||||
}
|
||||
|
||||
// IsNormal retourne vrai si aucun style n’est appliqué.
|
||||
func (st Style) IsNormal() bool {
|
||||
v, ok := st.Get()
|
||||
return ok && v == normal
|
||||
}
|
||||
|
||||
// Base retourne la liste des styles.
|
||||
func (st Style) Base() Option[int] {
|
||||
return st.Option
|
||||
}
|
||||
|
||||
// String retourne la chaine d’échappement ASCII du style.
|
||||
func (st Style) String() string {
|
||||
if v, ok := st.Get(); ok {
|
||||
return fmt.Sprintf("%d", v)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// Format formate le texte donné selon le style.
|
||||
func (st Style) Format(text string) string {
|
||||
if !st.IsDefined() {
|
||||
return text
|
||||
}
|
||||
return fmt.Sprintf(formatTpl, st.String(), text)
|
||||
}
|
||||
|
||||
// StyleOf retourne le style selon son nom.
|
||||
// Les noms possibles sont :
|
||||
// - normal : pas de style particulier
|
||||
// - bold : chaîne en gras
|
||||
// - italic : chaîne en italique
|
||||
// - underline : chaîne soulignée
|
||||
// - blink : chaîne clignotante
|
||||
// - inverted : switch entre les couleurs de police et d’arrière-plan
|
||||
// - crossed : chaîne rayée
|
||||
// Le préfixe ! peut être ajouté pour annuler le style.
|
||||
func StyleOf(name string) (st Style) {
|
||||
if v, ok := styles[name]; ok {
|
||||
return Style{Some(v)}
|
||||
}
|
||||
return
|
||||
}
|
||||
Loading…
Reference in New Issue