cdmnky
/
go
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

No comment

This commit is contained in:
B Newman 2025-05-16 14:45:54 -04:00
parent 78a1bd6c62
commit f20db37484
3 changed files with 805 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
ui/colors.go Normal file
View File

@ -0,0 +1,306 @@
package ui
import (
"fmt"
"os"
"runtime"
"strings"
)
const (
// Reset ...
Reset = "\x1b[0m"
// Bright ...
Bright = "\x1b[1m"
// Dim ...
Dim = "\x1b[2m"
// Underscore ...
Underscore = "\x1b[4m"
// Blink ...
Blink = "\x1b[5m"
// Reverse ...
Reverse = "\x1b[7m"
// Hidden ...
Hidden = "\x1b[8m"
)
const (
// FgBlack - Black foreground
FgBlack = "\x1b[30m"
// FgRed - Red foreground
FgRed = "\x1b[91m"
// FgGreen - Green foreground
FgGreen = "\x1b[92m"
// FgYellow - Yellow foreground
FgYellow = "\x1b[93m"
// FgBlue - Blue foreground
FgBlue = "\x1b[94m"
// FgMagenta - Magenta foreground
FgMagenta = "\x1b[95m"
// FgCyan - Cyan foreground
FgCyan = "\x1b[96m"
// FgWhite - White foreground
FgWhite = "\x1b[97m"
// FgOrange - Orange foreground
FgOrange = "\x1b[33m"
)
const (
// BgBlack - Black background
BgBlack = "\x1b[40m"
// BgRed - Red background
BgRed = "\x1b[41m"
// BgGreen - Green background
BgGreen = "\x1b[42m"
// BgYellow - Yellow background
BgYellow = "\x1b[43m"
// BgBlue - Blue background
BgBlue = "\x1b[44m"
// BgMagenta - Magenta background
BgMagenta = "\x1b[45m"
// BgCyan - Cyan background
BgCyan = "\x1b[46m"
// BgWhite - White background
BgWhite = "\x1b[47m"
)
// Color ...
type Color struct {
nocolor bool
}
// NewColor ...
func NewColor(nocolor bool) *Color {
return &Color{nocolor}
}
// color ...
func (c *Color) color(color string, msg ...interface{}) {
if !c.nocolor && colorterm() {
fmt.Print(color)
msg = append(msg, Reset)
}
fmt.Print(msg...)
}
// colorln ...
func (c *Color) colorln(color string, msg ...interface{}) {
if !c.nocolor && colorterm() {
fmt.Print(color)
msg = append(msg, Reset)
}
fmt.Println(msg...)
}
// colorf ...
func (c *Color) colorf(color, format string, i ...interface{}) {
if !c.nocolor && colorterm() {
fmt.Print(color)
format += Reset
}
fmt.Printf(format, i...)
}
// scolorf ...
func (c *Color) scolorf(color, format string, i ...interface{}) string {
if !c.nocolor && colorterm() {
format = color + format
format += Reset
}
return fmt.Sprintf(format, i...)
}
// colorterm
func colorterm() (supportscolor bool) {
term := os.Getenv("TERM")
supportscolor = true // going to assume yes
if len(term) > 0 {
if !(strings.Contains(term, "xterm-color") || strings.Contains(term, "256color")) {
supportscolor = false
}
}
if runtime.GOOS == "windows" {
supportscolor = false
}
return
}
// Black ...
func (c *Color) Black(msg ...interface{}) {
c.color(FgBlack, msg...)
}
// Blackln ...
func (c *Color) Blackln(msg ...interface{}) {
c.colorln(FgBlack, msg...)
}
// Blackf ...
func (c *Color) Blackf(format string, i ...interface{}) {
c.colorf(FgBlack, format, i...)
}
// Sblackf ...
func (c *Color) Sblackf(format string, i ...interface{}) {
c.scolorf(FgBlack, format, i...)
}
// Red ...
func (c *Color) Red(msg ...interface{}) {
c.color(FgRed, msg...)
}
// Redln ...
func (c *Color) Redln(msg ...interface{}) {
c.colorln(FgRed, msg...)
}
// Redf ...
func (c *Color) Redf(format string, i ...interface{}) {
c.colorf(FgRed, format, i...)
}
// Sredf ...
func (c *Color) Sredf(format string, i ...interface{}) string {
return c.scolorf(FgRed, format, i...)
}
// Green ...
func (c *Color) Green(msg ...interface{}) {
c.color(FgGreen, msg...)
}
// Greenln ...
func (c *Color) Greenln(msg ...interface{}) {
c.colorln(FgGreen, msg...)
}
// Greenf ...
func (c *Color) Greenf(format string, i ...interface{}) {
c.colorf(FgGreen, format, i...)
}
// Sgreenf ...
func (c *Color) Sgreenf(format string, i ...interface{}) string {
return c.scolorf(FgGreen, format, i...)
}
// Yellow ...
func (c *Color) Yellow(msg ...interface{}) {
c.color(FgYellow, msg...)
}
// Yellowln ...
func (c *Color) Yellowln(msg ...interface{}) {
c.colorln(FgYellow, msg...)
}
// Yellowf ...
func (c *Color) Yellowf(format string, i ...interface{}) {
c.colorf(FgYellow, format, i...)
}
// Syellowf ...
func (c *Color) Syellowf(format string, i ...interface{}) string {
return c.scolorf(FgYellow, format, i...)
}
// Blue ...
func (c *Color) Blue(msg ...interface{}) {
c.color(FgBlue, msg...)
}
// Blueln ...
func (c *Color) Blueln(msg ...interface{}) {
c.colorln(FgBlue, msg...)
}
// Bluef ...
func (c *Color) Bluef(format string, i ...interface{}) {
c.colorf(FgBlue, format, i...)
}
// Sbluef ...
func (c *Color) Sbluef(format string, i ...interface{}) string {
return c.scolorf(FgBlue, format, i...)
}
// Magenta ...
func (c *Color) Magenta(msg ...interface{}) {
c.color(FgMagenta, msg...)
}
// Magentaln ...
func (c *Color) Magentaln(msg ...interface{}) {
c.colorln(FgMagenta, msg...)
}
// Magentaf ...
func (c *Color) Magentaf(format string, i ...interface{}) {
c.colorf(FgMagenta, format, i...)
}
// Smagentaf ...
func (c *Color) Smagentaf(format string, i ...interface{}) string {
return c.scolorf(FgMagenta, format, i...)
}
// Cyan ...
func (c *Color) Cyan(msg ...interface{}) {
c.color(FgCyan, msg...)
}
// Cyanln ...
func (c *Color) Cyanln(msg ...interface{}) {
c.colorln(FgCyan, msg...)
}
// Cyanf ...
func (c *Color) Cyanf(format string, i ...interface{}) {
c.colorf(FgCyan, format, i...)
}
// Scyanf ...
func (c *Color) Scyanf(format string, i ...interface{}) string {
return c.scolorf(FgCyan, format, i...)
}
// Orange ...
func (c *Color) Orange(msg ...interface{}) {
c.color(FgOrange, msg...)
}
// Orangeln ...
func (c *Color) Orangeln(msg ...interface{}) {
c.colorln(FgOrange, msg...)
}
// Orangef ...
func (c *Color) Orangef(format string, i ...interface{}) {
c.colorf(FgOrange, format, i...)
}
// Sorangef ...
func (c *Color) Sorangef(format string, i ...interface{}) string {
return c.scolorf(FgOrange, format, i...)
}
// White ...
func (c *Color) White(msg ...interface{}) {
c.color(FgWhite, msg...)
}
// Whiteln ...
func (c *Color) Whiteln(msg ...interface{}) {
c.colorln(FgWhite, msg...)
}
// Whitef ...
func (c *Color) Whitef(format string, i ...interface{}) {
c.colorf(FgWhite, format, i...)
}
// Swhitef ...
func (c *Color) Swhitef(format string, i ...interface{}) string {
return c.scolorf(FgWhite, format, i...)
}

15
ui/gitinit.sh Executable file
View File

@ -0,0 +1,15 @@
#!/bin/bash
GITSVR="cdmnky.web"
VERSION="v3"
PROJECT="ui"
ssh $GITSVR "mkdir -p ./gitrepos/cdmnky.go/$VERSION/$PROJECT; cd ./gitrepos/cdmnky.go/$VERSION/$PROJECT; git init --bare"
#git config --global user.email "brian@bcnewman.com"
#git config --global user.name "Brian Newman"
git init
git add .
git commit -m "Initial commit"
git remote add origin $GITSVR:gitrepos/cdmnky.go/$VERSION/$PROJECT
git push -u origin master

484
ui/ui.go Normal file
View File

@ -0,0 +1,484 @@
package ui
import (
"bufio"
"fmt"
"os"
"sort"
"strconv"
"strings"
"time"
)
type UI struct {
appname string
version string
build string
usage string
Params Param
Other []string
debug bool
nocolor bool
}
// Returns a new UI object
func New(appname, version, build string) *UI {
return &UI{
appname: appname,
version: version,
build: build,
usage: "",
Params: Param{
params: map[string]map[string]Arg{
"--debug": {"descr": {"enable debug messages"}, "value": {"false"}, "envvar": {}, "required": {"false"}},
"--help": {"descr": {"show this screen"}, "value": {"false"}, "envvar": {}, "required": {"false"}},
"--nocolor": {"descr": {"disable color output"}, "value": {"false"}, "envvar": {}, "required": {"false"}},
},
},
Other: []string{},
debug: false,
nocolor: false,
}
}
type Arg []string
type Param struct {
params map[string]map[string]Arg
}
// Adds a new parameter to the UI parameter stack
func (x *Param) Add(name, descr, value, envvar, required string) {
wrk1 := Arg{}
if len(value) > 0 {
wrk1 = Arg{value}
}
wrk2 := Arg{}
if len(envvar) > 0 {
wrk2 = Arg{envvar}
}
wrk3 := Arg{"false"}
if len(required) > 0 {
wrk3 = Arg{required}
}
x.params[name] = map[string]Arg{"descr": {descr}, "value": wrk1, "envvar": wrk2, "required": wrk3}
}
// IsNocolor...
func (x *UI) IsNocolor() bool {
return x.nocolor
}
// IsDebug...
func (x *UI) IsDebug() bool {
return x.debug
}
// Usage...
func (x *UI) Usage(msg ...interface{}) {
if len(msg) > 0 {
x.usage = fmt.Sprintf("%v", msg...)
x.usage = strings.Replace(x.usage, "[appname]", x.appname, -1)
} else {
x.Outln(x.usage)
}
}
func (x *UI) Help() {
if len(x.usage) > 0 {
x.Outln("USAGE")
x.Outf(" %s \n", x.usage)
x.Outln()
}
x.Outln("PARAMETERS")
sortedKeys := []string{}
for key := range x.Params.params {
sortedKeys = append(sortedKeys, key)
}
sort.Strings(sortedKeys)
for _, key := range sortedKeys {
p := x.Params.params[key]
if key == "--debug" || key == "--nocolor" || key == "--help" {
continue
}
wrk1 := ""
if len(p["required"]) > 0 {
wrk1 = " required... " + p["required"][0]
}
if len(p["value"]) > 0 {
wrk1 += "\n default.... " + p["value"][0]
}
if len(p["envvar"]) > 0 {
wrk1 += "\n env var.... " + p["envvar"][0]
}
name := key + " ..............................................................................."
x.Outf(" %s %s\n", name[:80-len(p["descr"][0])-3], p["descr"][0])
x.Outln(wrk1)
}
x.Outln()
for key := range x.Params.params {
p := x.Params.params[key]
if key == "--debug" || key == "--nocolor" || key == "--help" {
wrk1 := ""
if len(p["required"]) > 0 {
wrk1 = " required... " + p["required"][0]
}
if len(p["value"]) > 0 {
wrk1 += "\n default.... " + p["value"][0]
}
if len(p["envvar"]) > 0 {
wrk1 += "\n env var.... " + p["envvar"][0]
}
name := key + " ..............................................................................."
x.Outf(" %s %s\n", name[:80-len(p["descr"][0])-3], p["descr"][0])
x.Outln(wrk1)
}
}
x.Outln()
}
func (x *UI) Parse(args []string) (err error) {
// parse default variables
tmp := []string{}
for idx, arg := range args {
if idx == 0 {
continue
}
if arg == "--help" {
x.Help()
os.Exit(0)
}
if arg == "--debug" {
x.debug = true
x.Params.params["--debug"]["value"] = Arg{"true"}
continue
}
if arg == "--nocolor" {
x.nocolor = true
x.Params.params["--nocolor"]["value"] = Arg{"true"}
continue
}
tmp = append(tmp, arg)
}
args = tmp
var required = map[string]bool{}
// determine required
for key := range x.Params.params {
if x.Params.params[key]["required"][0] == "true" {
required[key] = true
}
}
var isBool = map[string]bool{}
// determine if parameter is a bool
for key := range x.Params.params {
wrk := x.Params.params[key]["value"]
if len(wrk) > 0 && (wrk[0] == "true" || wrk[0] == "false") {
isBool[key] = true
}
}
// parse bool parameters
tmp = []string{}
for _, arg := range args {
if isBool[arg] {
x.Params.params[arg]["value"] = Arg{"true"}
continue
}
tmp = append(tmp, arg)
}
args = tmp
// parse environment variables
for key := range x.Params.params {
wrk := x.Params.params[key]["envvar"]
if len(wrk) > 0 {
tmp := os.Getenv(wrk[0])
if len(tmp) > 0 {
x.Params.params[key]["value"] = Arg{tmp}
}
}
}
// parse everything else ...
for idx := 0; idx < len(args); idx++ {
name := args[idx]
if n := x.Params.params[name]; n != nil {
idx++
if len(args) > (idx) {
x.Params.params[name]["value"] = append(x.Params.params[name]["value"], args[idx])
}
} else {
x.Other = append(x.Other, args[idx])
}
}
// make sure requred arguments were supplied
errcnt := 0
errmsg := ""
for key := range required {
param := x.Params.params[key]
if len(param["value"]) == 0 {
if errcnt > 0 {
errmsg += ", "
}
errmsg += key
errcnt++
}
}
if len(errmsg) > 0 {
return fmt.Errorf("missing required arguments: %s", errmsg)
}
return nil
}
func (x *UI) Banner() {
print := NewColor(x.nocolor)
print.Yellowf("%s, version %s, build %s \n", x.appname, x.version, x.build)
}
func (x *UI) String(arg string) (val string) {
val = ""
wrk := x.Params.params[arg]["value"]
if len(wrk) > 0 {
val = wrk[len(wrk)-1]
}
return
}
func (x *UI) Strings(arg string) (val []string) {
val = []string{}
for _, wrk := range x.Params.params[arg]["value"] {
if len(wrk) > 0 {
val = append(val, wrk)
}
}
return
}
func (x *UI) Bool(arg string) (val bool) {
val = false
wrk := x.Params.params[arg]["value"]
if len(wrk) > 0 {
val = wrk[len(wrk)-1] == "true"
}
return
}
// Int ...
func (x *UI) Int(name string) (val int) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
tmp, err = strconv.Atoi(wrk["value"][0])
if err != nil {
tmp = -999
}
val = tmp
}
return
}
// Int32 ...
func (x *UI) Int32(name string) (val int32) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
tmp, err = strconv.Atoi(wrk["value"][0])
if err != nil {
tmp = -999
}
val = int32(tmp)
}
return
}
// Int64 ...
func (x *UI) Int64(name string) (val int64) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
tmp, err = strconv.Atoi(wrk["value"][0])
if err != nil {
tmp = -999
}
val = int64(tmp)
}
return
}
// Ints ...
func (x *UI) Ints(name string) (val []int) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
for _, wrk1 := range wrk["value"] {
tmp, err = strconv.Atoi(wrk1)
if err != nil {
tmp = -999
}
val = append(val, tmp)
}
}
return
}
// Ints32 ...
func (x *UI) Ints32(name string) (val []int32) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
for _, wrk1 := range wrk["value"] {
tmp, err = strconv.Atoi(wrk1)
if err != nil {
tmp = -999
}
val = append(val, int32(tmp))
}
}
return
}
// Ints64 ...
func (x *UI) Ints64(name string) (val []int64) {
var err error
if wrk := x.Params.params[name]; wrk != nil {
tmp := 0
for _, wrk1 := range wrk["value"] {
tmp, err = strconv.Atoi(wrk1)
if err != nil {
tmp = -999
}
val = append(val, int64(tmp))
}
}
return
}
// Out ...
func (x *UI) Out(msg ...interface{}) {
fmt.Print(msg...)
}
// Outln ...
func (x *UI) Outln(msg ...interface{}) {
fmt.Println(msg...)
}
// Outf ...
func (x *UI) Outf(format string, i ...interface{}) {
fmt.Printf(format, i...)
}
// Info ...
func (x *UI) Info(msg ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sgreenf("[info] "))
fmt.Print(msg...)
}
// Infoln ...
func (x *UI) Infoln(msg ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sgreenf("[info] "))
fmt.Println(msg...)
}
// Infof ...
func (x *UI) Infof(format string, i ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sgreenf("[info] "))
fmt.Printf(format, i...)
}
// Error ...
func (x *UI) Error(msg ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sredf("[error] "))
fmt.Print(msg...)
}
// Errorln ...
func (x *UI) Errorln(msg ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sredf("[error] "))
fmt.Println(msg...)
}
// Errorf ...
func (x *UI) Errorf(format string, i ...interface{}) {
fmt.Print(NewColor(x.nocolor).Sredf("[error] "))
fmt.Printf(format, i...)
}
// Debug ...
func (x *UI) Debug(msg ...interface{}) {
if x.debug {
fmt.Print(NewColor(x.nocolor).Syellowf("[debug] "))
fmt.Print(msg...)
}
}
// Debugln ...
func (x *UI) Debugln(msg ...interface{}) {
if x.debug {
fmt.Print(NewColor(x.nocolor).Syellowf("[debug] "))
fmt.Println(msg...)
}
}
// Debugf ...
func (x *UI) Debugf(format string, i ...interface{}) {
if x.debug {
fmt.Print(NewColor(x.nocolor).Syellowf("[debug] "))
fmt.Printf(format, i...)
}
}
// Log ...
func (x *UI) Log(msg ...interface{}) {
ts := time.Now().Format("2006.01.02 03:04:05PM")
fmt.Print("[" + ts + "] ")
fmt.Print(msg...)
}
// Logln ...
func (x *UI) Logln(msg ...interface{}) {
ts := time.Now().Format("2006.01.02 03:04:05PM")
fmt.Print("[" + ts + "] ")
fmt.Println(msg...)
}
// Logf ...
func (x *UI) Logf(format string, i ...interface{}) {
ts := time.Now().Format("2006.01.02 03:04:05PM")
fmt.Print("[" + ts + "] ")
fmt.Printf(format, i...)
}
// Prompt ...
func (x *UI) Prompt(msg ...interface{}) string {
r := bufio.NewReader(os.Stdin)
fmt.Print(NewColor(x.nocolor).Sredf("%s", msg...))
//fmt.Print(msg...)
line, _, err := r.ReadLine()
if err != nil {
return err.Error()
}
return string(line)
}
// Clear ...
func (x *UI) Clear() {
fmt.Printf("\033[2J\033[1;1H")
}