bvaudour
/
gob
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Module format

This commit is contained in:
Benjamin VAUDOUR 2023-09-23 21:42:21 +02:00
parent 0a1722dd44
commit 34cb5b19ca
4 changed files with 643 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
format/align.go Normal file
View File

@ -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)
}

222
format/color.go Normal file
View File

@ -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)
}

170
format/format.go Normal file
View File

@ -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)
}

95
format/style.go Normal file
View File

@ -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
}