chore: add color, formatting, and begin refactor
b3b9bdd2
3 file(s) · +92 −120
| 1 | - | package internal |
|
| 1 | + | package internal |
|
| 2 | 2 | ||
| 3 | - | import ( |
|
| 3 | + | import ( |
|
| 4 | 4 | "fmt" |
|
| 5 | - | "time" |
|
| 6 | 5 | "math/rand" |
|
| 6 | + | "time" |
|
| 7 | 7 | ) |
|
| 8 | 8 | ||
| 9 | - | func TypePrint(s string) { |
|
| 9 | + | const ( |
|
| 10 | + | Reset = "\033[0m" |
|
| 11 | + | Bold = "\033[1m" |
|
| 12 | + | Red = "\033[31m" |
|
| 13 | + | Green = "\033[32m" |
|
| 14 | + | Blue = "\033[34m" |
|
| 15 | + | Cyan = "\033[36m" |
|
| 16 | + | ) |
|
| 17 | + | ||
| 18 | + | type Row struct { |
|
| 19 | + | Key string |
|
| 20 | + | Value string |
|
| 21 | + | } |
|
| 22 | + | ||
| 23 | + | func Colorize(color, s string) string { |
|
| 24 | + | return color + s + Reset |
|
| 25 | + | } |
|
| 26 | + | ||
| 27 | + | func PrintRows(rows []Row, typewriter bool) { |
|
| 28 | + | width := labelWidth(rows) |
|
| 29 | + | ||
| 30 | + | for _, row := range rows { |
|
| 31 | + | label := Colorize(Bold+Green, fmt.Sprintf("%-*s", width, row.Key)) |
|
| 32 | + | line := label + " " + row.Value |
|
| 33 | + | ||
| 34 | + | if typewriter { |
|
| 35 | + | TypeString(line) |
|
| 36 | + | fmt.Println() |
|
| 37 | + | } else { |
|
| 38 | + | fmt.Println(line) |
|
| 39 | + | } |
|
| 40 | + | } |
|
| 41 | + | } |
|
| 42 | + | ||
| 43 | + | func labelWidth(rows []Row) int { |
|
| 44 | + | width := 0 |
|
| 45 | + | for _, row := range rows { |
|
| 46 | + | if w := len(row.Key) + 1; w > width { |
|
| 47 | + | width = w |
|
| 48 | + | } |
|
| 49 | + | } |
|
| 50 | + | return width |
|
| 51 | + | } |
|
| 52 | + | ||
| 53 | + | func TypeString(s string) { |
|
| 10 | 54 | for _, char := range s { |
|
| 11 | 55 | fmt.Print(string(char)) |
|
| 12 | 56 |
| 9 | 9 | "syscall" |
|
| 10 | 10 | "time" |
|
| 11 | 11 | "path/filepath" |
|
| 12 | - | "errors" |
|
| 13 | 12 | ) |
|
| 14 | 13 | ||
| 15 | - | func GetHostname() (string, error) { |
|
| 14 | + | func GetHostname() Row { |
|
| 16 | 15 | hostname, err := os.Hostname() |
|
| 17 | 16 | if err != nil { |
|
| 18 | - | return "", err |
|
| 17 | + | hostname = "Unknown" |
|
| 19 | 18 | } |
|
| 20 | 19 | user := os.Getenv("USER") |
|
| 21 | 20 | if user == "" { |
|
| 22 | - | return "", err |
|
| 21 | + | user = "Unknown" |
|
| 23 | 22 | } |
|
| 24 | - | return fmt.Sprintf("%s@%s\n", user, hostname), nil |
|
| 23 | + | host := fmt.Sprintf("%s@%s", user, hostname) |
|
| 24 | + | return Row{Key: "Host", Value: host} |
|
| 25 | 25 | } |
|
| 26 | 26 | ||
| 27 | - | func GetDistro() (string, error) { |
|
| 27 | + | func GetDistro() string { |
|
| 28 | 28 | file, err := os.Open("/etc/os-release") |
|
| 29 | 29 | if err != nil { |
|
| 30 | - | return "", err |
|
| 30 | + | return "" |
|
| 31 | 31 | } |
|
| 32 | 32 | defer file.Close() |
|
| 33 | 33 | ||
| 36 | 36 | line := scanner.Text() |
|
| 37 | 37 | if strings.HasPrefix(line, "PRETTY_NAME=") { |
|
| 38 | 38 | value := strings.TrimPrefix(line, "PRETTY_NAME=") |
|
| 39 | - | return strings.Trim(value, `"`), nil |
|
| 39 | + | return strings.Trim(value, `"`) |
|
| 40 | 40 | } |
|
| 41 | 41 | } |
|
| 42 | - | return "", scanner.Err() |
|
| 42 | + | return "" |
|
| 43 | 43 | } |
|
| 44 | 44 | ||
| 45 | - | func GetMachine() (string, error) { |
|
| 45 | + | func GetMachine() string { |
|
| 46 | 46 | brandFile, err := os.ReadFile("/sys/class/dmi/id/sys_vendor") |
|
| 47 | 47 | if err != nil { |
|
| 48 | - | return "", err |
|
| 48 | + | return "" |
|
| 49 | 49 | } |
|
| 50 | 50 | productFile, err := os.ReadFile("/sys/class/dmi/id/product_name") |
|
| 51 | 51 | if err != nil { |
|
| 52 | - | return "", err |
|
| 52 | + | return "" |
|
| 53 | 53 | } |
|
| 54 | 54 | ||
| 55 | 55 | brand := strings.TrimSpace(string(brandFile)) |
|
| 56 | 56 | product := strings.TrimSpace(string(productFile)) |
|
| 57 | 57 | ||
| 58 | - | return fmt.Sprintf("%s %s", brand, product), nil |
|
| 58 | + | return fmt.Sprintf("%s %s", brand, product) |
|
| 59 | 59 | } |
|
| 60 | 60 | ||
| 61 | - | func GetKernel() (string, error) { |
|
| 61 | + | func GetKernel() string { |
|
| 62 | 62 | kernelFile, err := os.ReadFile("/proc/sys/kernel/osrelease") |
|
| 63 | 63 | if err != nil { |
|
| 64 | - | return "", err |
|
| 64 | + | return "" |
|
| 65 | 65 | } |
|
| 66 | 66 | kernel := strings.TrimSpace(string(kernelFile)) |
|
| 67 | - | return kernel, nil |
|
| 67 | + | return kernel |
|
| 68 | 68 | } |
|
| 69 | 69 | ||
| 70 | - | func GetPackages() (string, error) { |
|
| 71 | - | // Packages - /lib/apk/db/installed count P: |
|
| 70 | + | func GetPackages() string { |
|
| 72 | 71 | var count int |
|
| 73 | 72 | file, err := os.Open("/lib/apk/db/installed") |
|
| 74 | 73 | if err != nil { |
|
| 75 | - | return "", err |
|
| 74 | + | return "" |
|
| 76 | 75 | } |
|
| 77 | 76 | defer file.Close() |
|
| 78 | 77 | ||
| 86 | 85 | ||
| 87 | 86 | stringCount := strconv.Itoa(count) |
|
| 88 | 87 | ||
| 89 | - | return stringCount, nil |
|
| 88 | + | return stringCount + " (apk)" |
|
| 90 | 89 | } |
|
| 91 | 90 | ||
| 92 | - | func GetShell() (string, error) { |
|
| 91 | + | func GetShell() string { |
|
| 93 | 92 | shellEnv := os.Getenv("SHELL") |
|
| 94 | 93 | if shellEnv == "" { |
|
| 95 | - | return "", errors.New("Could not fetch shell") |
|
| 94 | + | return "" |
|
| 96 | 95 | } |
|
| 97 | 96 | ||
| 98 | 97 | shell := filepath.Base(shellEnv) |
|
| 99 | 98 | ||
| 100 | - | return shell, nil |
|
| 99 | + | return shell |
|
| 101 | 100 | } |
|
| 102 | 101 | ||
| 103 | - | func GetCpu() (string, error) { |
|
| 102 | + | func GetCpu() string { |
|
| 104 | 103 | file, err := os.Open("/proc/cpuinfo") |
|
| 105 | 104 | if err != nil { |
|
| 106 | - | return "", err |
|
| 105 | + | return "" |
|
| 107 | 106 | } |
|
| 108 | 107 | defer file.Close() |
|
| 109 | 108 | ||
| 113 | 112 | if strings.HasPrefix(line, "model name") { |
|
| 114 | 113 | value := strings.TrimPrefix(line, "model name") |
|
| 115 | 114 | cleanSpace := strings.TrimSpace(value) |
|
| 116 | - | valueClean := strings.TrimPrefix(cleanSpace, ":") |
|
| 117 | - | return valueClean, nil |
|
| 115 | + | valueClean := strings.TrimPrefix(cleanSpace, ": ") |
|
| 116 | + | return valueClean |
|
| 118 | 117 | } |
|
| 119 | 118 | } |
|
| 120 | - | return "", nil |
|
| 119 | + | return "" |
|
| 121 | 120 | } |
|
| 122 | 121 | ||
| 123 | - | func GetMemory() (string, error) { |
|
| 122 | + | func GetMemory() string { |
|
| 124 | 123 | var memTotal string |
|
| 125 | 124 | var memAvailable string |
|
| 126 | 125 | file, err := os.Open("/proc/meminfo") |
|
| 127 | 126 | if err != nil { |
|
| 128 | - | return "", err |
|
| 127 | + | return "" |
|
| 129 | 128 | } |
|
| 130 | 129 | defer file.Close() |
|
| 131 | 130 | ||
| 158 | 157 | memAvailableGb := float64(memAvailableInt) / float64(1024) / float64(1024) |
|
| 159 | 158 | memUsed := memTotalGb - memAvailableGb |
|
| 160 | 159 | ||
| 161 | - | result := fmt.Sprintf("%.2f Gb / %.2f Gb", memUsed, memTotalGb) |
|
| 162 | - | return result, scanner.Err() |
|
| 160 | + | result := fmt.Sprintf("%.2f GiB / %.2f GiB", memUsed, memTotalGb) |
|
| 161 | + | return result |
|
| 163 | 162 | } |
|
| 164 | 163 | ||
| 165 | - | func GetUptime() (string, error) { |
|
| 164 | + | func GetUptime() string { |
|
| 166 | 165 | var si syscall.Sysinfo_t |
|
| 167 | 166 | syscall.Sysinfo(&si) |
|
| 168 | 167 | ||
| 171 | 170 | hours := int(uptime.Hours()) |
|
| 172 | 171 | minutes := int(uptime.Minutes()) % 60 |
|
| 173 | 172 | ||
| 174 | - | return fmt.Sprintf("%d hours, %d mins", hours, minutes), nil |
|
| 173 | + | return fmt.Sprintf("%d hours, %d mins", hours, minutes) |
|
| 175 | 174 | } |
|
| 1 | 1 | package main |
|
| 2 | 2 | ||
| 3 | 3 | import ( |
|
| 4 | - | "fmt" |
|
| 5 | - | "os" |
|
| 6 | 4 | internal "github.com/stevedylandev/gobble/internal" |
|
| 7 | 5 | ) |
|
| 8 | 6 | ||
| 9 | 7 | // Gobble: fetch in go for fun |
|
| 10 | - | // Shell env |
|
| 11 | - | // |
|
| 12 | - | // Order: |
|
| 13 | - | // Host - Done |
|
| 14 | - | // Machine - Done |
|
| 15 | - | // Kernel - Done |
|
| 16 | - | // Distro - Done |
|
| 17 | - | // Packages - Done |
|
| 18 | - | // Shell - Done |
|
| 19 | - | // Terminal? |
|
| 20 | - | // Uptime - Done |
|
| 21 | - | // CPU - Done |
|
| 22 | - | // GPU - |
|
| 23 | - | // Memory - Done |
|
| 24 | - | // |
|
| 25 | - | // Need to figure out colors and printing design |
|
| 26 | 8 | ||
| 27 | 9 | func main() { |
|
| 28 | - | hostname, err := internal.GetHostname() |
|
| 29 | - | if err != nil { |
|
| 30 | - | fmt.Println("error:", err) |
|
| 31 | - | os.Exit(1) |
|
| 10 | + | rows := []internal.Row { |
|
| 11 | + | internal.GetHostname(), |
|
| 12 | + | {"Machine", internal.GetMachine()}, |
|
| 13 | + | {"Kernel", internal.GetKernel()}, |
|
| 14 | + | {"Distro", internal.GetDistro()}, |
|
| 15 | + | {"Packages", internal.GetPackages()}, |
|
| 16 | + | {"Shell", internal.GetShell()}, |
|
| 17 | + | {"CPU", internal.GetCpu()}, |
|
| 18 | + | {"Memory", internal.GetMemory()}, |
|
| 19 | + | {"Uptime", internal.GetUptime()}, |
|
| 32 | 20 | } |
|
| 33 | - | internal.TypePrint(hostname) |
|
| 34 | - | fmt.Println("-----------------------------") |
|
| 35 | - | ||
| 36 | - | machine, err := internal.GetMachine() |
|
| 37 | - | if err != nil { |
|
| 38 | - | fmt.Println("error:", err) |
|
| 39 | - | os.Exit(1) |
|
| 40 | - | } |
|
| 41 | - | internal.TypePrint("Machine: " + machine) |
|
| 42 | - | ||
| 43 | - | kernel, err := internal.GetKernel() |
|
| 44 | - | if err != nil { |
|
| 45 | - | fmt.Println("error:", err) |
|
| 46 | - | os.Exit(1) |
|
| 47 | - | } |
|
| 48 | - | internal.TypePrint("Kernel: " + kernel) |
|
| 49 | - | ||
| 50 | - | distro, err := internal.GetDistro() |
|
| 51 | - | if err != nil { |
|
| 52 | - | fmt.Println("error:", err) |
|
| 53 | - | os.Exit(1) |
|
| 54 | - | } |
|
| 55 | - | internal.TypePrint("Disto: " + distro) |
|
| 56 | - | ||
| 57 | - | packages, err := internal.GetPackages() |
|
| 58 | - | if err != nil { |
|
| 59 | - | fmt.Println("error:", err) |
|
| 60 | - | os.Exit(1) |
|
| 61 | - | } |
|
| 62 | - | internal.TypePrint("Packages: " + packages + " (apk)") |
|
| 63 | - | ||
| 64 | - | shell, err := internal.GetShell() |
|
| 65 | - | if err != nil { |
|
| 66 | - | fmt.Println("error:", err) |
|
| 67 | - | os.Exit(1) |
|
| 68 | - | } |
|
| 69 | - | internal.TypePrint("Shell: " + shell) |
|
| 70 | - | ||
| 71 | - | cpu, err := internal.GetCpu() |
|
| 72 | - | if err != nil { |
|
| 73 | - | fmt.Println("error:", err) |
|
| 74 | - | os.Exit(1) |
|
| 75 | - | } |
|
| 76 | - | internal.TypePrint("CPU: " + cpu) |
|
| 77 | - | ||
| 78 | - | memory, err := internal.GetMemory() |
|
| 79 | - | if err != nil { |
|
| 80 | - | fmt.Println("error:", err) |
|
| 81 | - | os.Exit(1) |
|
| 82 | - | } |
|
| 83 | - | internal.TypePrint("Memory: " + memory) |
|
| 84 | - | ||
| 85 | - | uptime, err := internal.GetUptime() |
|
| 86 | - | if err != nil { |
|
| 87 | - | fmt.Println("error:", err) |
|
| 88 | - | os.Exit(1) |
|
| 89 | - | } |
|
| 90 | - | internal.TypePrint("Uptime: " + uptime) |
|
| 91 | - | ||
| 92 | - | os.Exit(0) |
|
| 21 | + | internal.PrintRows(rows, false) |
|
| 93 | 22 | } |
|
| 94 | 23 |