Skip to content

SimonWaldherr/golibs

Folders and files

NameName
Last commit message
Last commit date
Oct 1, 2022
Nov 29, 2015
Jun 13, 2022
Jul 23, 2024
Jul 22, 2024
Jun 13, 2022
Oct 12, 2015
Apr 7, 2023
Jun 13, 2022
Jun 27, 2022
Apr 7, 2023
Apr 7, 2023
Jun 27, 2022
Apr 7, 2023
Apr 7, 2023
Jul 21, 2024
Jun 27, 2022
Apr 7, 2023
Nov 29, 2015
Oct 22, 2015
Apr 7, 2023
Apr 7, 2023
Aug 21, 2022
Jul 16, 2024
Jun 19, 2024
Apr 7, 2023
Jul 2, 2018
Apr 7, 2023
Jun 19, 2024
Jul 18, 2024
Apr 7, 2023
Apr 7, 2023
Apr 7, 2023
Sep 6, 2015
Jul 21, 2024
Mar 13, 2016
Jun 27, 2022
Aug 22, 2022
Aug 22, 2022
Jul 22, 2024
Apr 7, 2023
Aug 22, 2022
Aug 22, 2022
Apr 7, 2023
Feb 21, 2016

Repository files navigation

golibs

golang functions (to be included in other projects)

go get -u -t simonwaldherr.de/go/golibs/...

coverage & tests

go test ./...
. service info
Audit github.com test via GitHub Workflow
Go Report Card goreportcard.com report card
Coverage Status go tool cover
FOSSA Status fossa.io license report
License MIT free + open source license
GoDoc godoc.org documentation
GoDoc godoc @ github.io documentation
DOI zenodo.org Digital Object Identifier

each new build gets tested in multiple steps:

  • on development i regularly type go test from time to time to check the test suite
  • also there are a few go apps in the examples-folder which i test to build and run
  • on commit, git automatically runs the pre-commit-hook shell script
  • after a commit gets pushed to GitHub, the following tests are started via Webhooks and Services
    • Travis CI build the lib and all tests on docker containers with the go versions noted in .travis.yml
    • semaphoreci, yet another (linux (ubuntu) based) ci service

ToC

  • ansi can print colored and styled text to your terminal
  • arg simplifies cli flags (arguments)
  • as can convert most standard data types to most other data types
  • bitmask set and get bits in a bitmask
  • cache is an easy and small caching package
  • cachedfile simplifies reading and writing from and to disk and adds caching
  • channel simplifies channel operations, e.g. sending the same data to multiple receivers
  • csv load and parse CSV file
  • file wraps around the standard functions to simplify reading and writing on disk
  • foreach calls a given function for each element of a [ JSON-string ]
  • gcurses enabling the development of text user interface applications
  • gopath provides an easy way to get system information
  • graphics can manipulate images
  • http make easy and fast HTTP(S) requests
  • log helps on logging your applications status
  • re helps you whenever you have to do something multiple times
  • regex is a layer to speed up your regular expression development
  • rss is a rss feed parser based on Golangs std xml package
  • semver is a semantic version parsing/checking package
  • ssl generates ssl certificates for https
  • stack can store your values in stacks and rings
  • structs use structs like maps
  • table prints structs like ASCII or Markdown tables
  • xmath provides a few mathematical functions like Sum, Median, Harmonic-mean, …
  • xtime xtime implements a subset of strftime

WARNING

some functions in this repo enables you to write really bad code - I wrote it anyway because:

  • sometimes you need a quick and dirty solution
  • it shows you possible ways, feel free to fork and customize
  • mostly bad go code is better than good php code - every aspect in golang is designed to prevent from bad code

BUT: please remember that you can do things more performantly e.g. converting a string to a float is much faster done with strconv.ParseFloat than with as.Float.

sublibs

ansi - GoDoc

import "simonwaldherr.de/go/golibs/ansi"

ansi can print colored and styled text to your terminal:

  • green, yellow and red strings:
log.Println(ansi.Color("INFO: everything is fine", ansi.Green))
log.Println(ansi.Color("WARNING: not everything is fine", ansi.Yellow))
log.Println(ansi.Color("ERROR: OMG!!!", ansi.Red))
  • bold and underlined text:
fmt.Printf("this is %v and %v text", ansi.Bold("bold"), ansi.Underline("underlined"))

arg - GoDoc

import "simonwaldherr.de/go/golibs/arg"

the arg package simplifies cli flags (arguments)

as - GoDoc

import "simonwaldherr.de/go/golibs/as"

with as you can convert most standard data types to most other data types e.g.

  • int to string:
var x string = as.String(int(32))
  • string to int:
var x int = as.Int("32")
  • string to time:
var x time.Time = as.Time("31.12.2014")

bitmask - GoDoc

import "simonwaldherr.de/go/golibs/bitmask"

with bitmask you can set and get bits to and from a bitmask:

i := bitmask.New(0b11111111)
i.Set(0, false)

cache - GoDoc

import "simonwaldherr.de/go/golibs/cache"

cachedfile - GoDoc

import "simonwaldherr.de/go/golibs/cachedfile"

cachedfile simplifies reading and writing from and to disk and adds caching

do

str := "Neque porro quisquam est, qui dolorem ipsum, quia dolor sit, amet, consectetur, adipisci velit."
err := cachedfile.Write("filename.txt", str, false)

and in less then 15 minutes this

str, _ := cachedfile.Read("filename.txt")

and there will be no file access to disk. If you kill the App, wait 15 min or call cachedfile.Stop() the cached content will be exported to disk.

channel - GoDoc

import "simonwaldherr.de/go/golibs/channel"

channel simplifies channel operations, e.g. sending the same data to multiple receivers

con := channel.Init()

receiver01 := con.AddReceiver()
receiver02 := con.AddReceiver()
receiver03 := con.AddReceiver()

go func() {
  fmt.Println(<-receiver01)
}()

go func() {
  fmt.Println(<-receiver02)
}()

go func() {
  fmt.Println(<-receiver03)
}()

transmitter01 := con.AddTransmitter()

transmitter01 <- "Hello World"

csv - GoDoc

import "simonwaldherr.de/go/golibs/csv"

file - GoDoc

import "simonwaldherr.de/go/golibs/file"

file wraps around the standard functions to simplify reading and writing on disk

str := "Neque porro quisquam est, qui dolorem ipsum, quia dolor sit, amet, consectetur, adipisci velit."
err := file.Write("filename.txt", str, false)

Besides simple reading and writing, the package also contains functions to test file statuses, read large files by small blocks, clear, rename and delete files. There is even a function for do things with each file in a directory (even with subfolders):

err := file.Each("..", true, func(filename, extension, filepath string, dir bool, fileinfo os.FileInfo) {
	if extension == "go" && !dir {
		t.Logf("%v, %v, %v, %v\n", filename, filepath, dir, fileinfo)
	}
}

If you need the absolute path to a file, but only have a relative path, you can use file.GetAbsolutePath("~/path/to/file.txt").

foreach - GoDoc

import "simonwaldherr.de/go/golibs/foreach"

foreach calls a given function for each element of a [ JSON-string ]

gcurses - GoDoc

import "simonwaldherr.de/go/golibs/gcurses"

gcurses is a terminal control library for Unixoide systems, enabling the development of text user interface applications.

Named after the "GUI-like" terminal application toolkit ncurses (new curses) which is named after the original curses. This library is in a very early stage.

package main

import (
  "fmt"
  "simonwaldherr.de/go/golibs/gcurses"
  "time"
)

func main() {
  writer := gcurses.New()

  writer.Start()

  for i := 0; i < 100; i++ {
    fmt.Fprintf(writer, "Count till one hundred: %d\nStill counting ...\n", i)
    time.Sleep(time.Millisecond * 10)
  }

  time.Sleep(time.Millisecond * 500)
  fmt.Fprintln(writer, "Finished counting")

  writer.Stop()
}

gopath - GoDoc

import "simonwaldherr.de/go/golibs/gopath"

gopath provides an easy way to get system information

to read a config file in which is in the same file as the executable, you can do something like this:

package main

import (
  "fmt"
  "path/filepath"
  "simonwaldherr.de/go/golibs/file"
  "simonwaldherr.de/go/golibs/gopath"
)

func main() {
  dir := gopath.Dir()
  config := file.Read(filepath.Join(dir, "config.yaml"))
  
  ...

graphics - GoDoc

import "simonwaldherr.de/go/golibs/graphics"

with graphics you can manipulate images

img := graphics.EachPixel(file, func(r, g, b, a uint8) (uint8, uint8, uint8, uint8) {
	return g, b, r, a
})

you even can apply filters to images:

file, _ := os.Open("./original.png")
defer file.Close()

img, _, err := image.Decode(file)

img = Edgedetect(img)

out, _ := os.Create("./edgeDetect.png")

png.Encode(out, img)
fd.Close()

http - GoDoc

import "simonwaldherr.de/go/golibs/http"

log - GoDoc

import "simonwaldherr.de/go/golibs/log"

re - GoDoc

import "simonwaldherr.de/go/golibs/re"

re helps you whenever you have to do something multiple times

data, stop := re.Do(time.Second * 5, func(data chan<- interface{}) {
	data <- fmt.Sprintf("%v\n", time.Now().Format("02.01.2006 15:04:05"))
})

regex - GoDoc

import "simonwaldherr.de/go/golibs/regex"

regex is a layer to speed up your regular expression development

str, err := regex.ReplaceAllString("Ipsum Lorem", "([^ ]+) ([^ ]+)", "$2 $1")

rss - GoDoc

import "simonwaldherr.de/go/golibs/rss"

rss is a rss feed parser based on Golangs std xml package

podcast, err := rss.Read(url)
if err == nil {
  for _, episode := range podcast.Items {
    fmt.Println(episode.Title)
  }
}

ssl - GoDoc

import "simonwaldherr.de/go/golibs/ssl"

ssl generates ssl certificates for https

err := ssl.Generate(options)

stack - GoDoc

import "simonwaldherr.de/go/golibs/stack"

with stack you can store your values in stacks and rings

array := stack.Lifo()
array.Push(as.Bytes(12.34))
array.Push(as.Float(13.37))
array.Push(as.String(23.0))
for array.Len() > 0 {
	log.Println(array.Pop())
}

structs - GoDoc

import "simonwaldherr.de/go/golibs/structs"

xmath - GoDoc

import "simonwaldherr.de/go/golibs/xmath"

xmath provides a few mathematical functions like Max, Min, Sum, Median, Harmonic-mean, ...

var f = []float64{.5, 1.33, 2.66, 3.99, 13.37, 23.42, 42.000003}

fmt.Printf("Max: %v\n", xmath.Max(f))
fmt.Printf("Min: %v\n", xmath.Min(f))
fmt.Printf("Sum: %v\n", xmath.Sum(f))

fmt.Printf("Median:     %v\n", xmath.Median(f))
fmt.Printf("Arithmetic: %v\n", xmath.Arithmetic(f))
fmt.Printf("Harmonic:   %v\n", xmath.Harmonic(f))
fmt.Printf("Geometric:  %v\n", xmath.Geometric(f))

xtime - GoDoc

import "simonwaldherr.de/go/golibs/xtime"

xtime implements a subset of strftime

t, _ := time.Now()
fmt.Println(xtime.Fmt("%Y-%m-%d %H:%M:%S", t))