exerr [WIP]

.gitea/workflows/tests.yml

@@ -1,55 +0,0 @@
-
-# https://docs.gitea.com/next/usage/actions/quickstart
-# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
-# https://docs.github.com/en/actions/learn-github-actions/contexts#github-context
-
-name: Build Docker and Deploy
-run-name: Build & Deploy ${{ gitea.ref }} on ${{ gitea.actor }}
-
-on:
-  push:
-    branches:
-      - '*'
-      - '**'
-
-
-jobs:
-  run_tests:
-    name: Run goext test-suite  
-    runs-on: bfb-cicd-latest
-    steps:
-
-      - name: Check out code
-        uses: actions/checkout@v3
-
-      - name: Setup go
-        uses: actions/setup-go@v4
-        with:
-          go-version-file: '${{ gitea.workspace }}/go.mod'
-
-      - name: Setup packages
-        uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: curl python3
-          version: 1.0
-
-      - name: go version
-        run: go version
-
-      - name: Run tests
-        run: cd "${{ gitea.workspace }}" && make test
-
-      - name: Send failure mail
-        if: failure()
-        uses: dawidd6/action-send-mail@v3
-        with:
-          server_address: smtp.fastmail.com
-          server_port: 465
-          secure: true
-          username: ${{secrets.MAIL_USERNAME}}
-          password: ${{secrets.MAIL_PASSWORD}}
-          subject: Pipeline on '${{ gitea.repository }}' failed
-          to: ${{ steps.commiter_info.outputs.MAIL }}
-          from: Gitea Actions <gitea_actions@blackforestbytes.de>
-          body: "Go to https://gogs.blackforestbytes.com/${{ gitea.repository }}/actions"
-

.idea/.gitignore

@@ -6,5 +6,3 @@
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
-# GitHub Copilot persisted chat sessions
-/copilot/chatSessions

.idea/goext.iml

@@ -1,10 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="WEB_MODULE" version="4">
-  <component name="Go" enabled="true">
-    <buildTags>
-      <option name="goVersion" value="1.19" />
-    </buildTags>
-  </component>
+  <component name="Go" enabled="true" />
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$" />
     <orderEntry type="inheritedJdk" />

.idea/golinter.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GoLinterSettings">
-    <option name="checkGoLinterExe" value="false" />
-  </component>
-</project>

.idea/sqldialects.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="SqlDialectMappings">
-    <file url="file://$PROJECT_DIR$/sq/sq_test.go" dialect="SQLite" />
-  </component>
-</project>

Makefile

@@ -3,15 +3,7 @@ run:
 	echo "This is a library - can't be run" && false
 
 test:
-	# go test ./...
-	which gotestsum || go install gotest.tools/gotestsum@latest
-	gotestsum --format "testname" -- -tags="timetzdata sqlite_fts5 sqlite_foreign_keys" "./..."
-
-test-in-docker:
-	tag="goext_temp_test_image:$(shell uuidgen | tr -d '-')";        \
-	docker build --tag $$tag . -f .gitea/workflows/Dockerfile_tests; \
-	docker run --rm $$tag;                                           \
-	docker rmi $$tag
+	go test ./...
 
 version:
 	_data/version.sh

README.md

@@ -6,106 +6,3 @@ A collection of general & useful library methods
 This should not have any heavy dependencies (gin, mongo, etc) and add missing basic language features...
 
 Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
-
-
-## Packages:
-
-| Name        | Maintainer | Description                                                                                                   |
-|-------------|------------|---------------------------------------------------------------------------------------------------------------|
-| langext     | Mike       | General uttility/helper functions, (everything thats missing from go standard library)                        |
-| mathext     | Mike       | Utility/Helper functions for math                                                                             |
-| cryptext    | Mike       | Utility/Helper functions for encryption                                                                       |
-| syncext     | Mike       | Utility/Helper funtions for multi-threading / mutex / channels                                                |
-| dataext     | Mike       | Various useful data structures                                                                                |
-| zipext      | Mike       | Utility for zip/gzip/tar etc                                                                                  |
-| reflectext  | Mike       | Utility for golang reflection                                                                                 |
-| fsext       | Mike       | Utility for filesytem access                                                                                  |
-| ctxext      | Mike       | Utility for context.Context                                                                                   |
-|             |            |                                                                                                               |
-| mongoext    | Mike       | Utility/Helper functions for mongodb (kinda abandoned)                                                        |
-| cursortoken | Mike       | MongoDB cursortoken implementation                                                                            |
-| pagination  | Mike       | Pagination implementation                                                                                     |
-|             |            |                                                                                                               |
-| totpext     | Mike       | Implementation of TOTP (2-Factor-Auth)                                                                        |
-| termext     | Mike       | Utilities for terminals (mostly color output)                                                                 |
-| confext     | Mike       | Parses environment configuration into structs                                                                 |
-| cmdext      | Mike       | Runner for external commands/processes                                                                        |
-|             |            |                                                                                                               |
-| sq          | Mike       | Utility functions for sql based databases (primarily sqlite)                                                  |
-| tst         | Mike       | Utility functions for unit tests                                                                              |
-|             |            |                                                                                                               |
-| rfctime     | Mike       | Classes for time seriallization, with different marshallign method for mongo and json                         |
-| gojson      | Mike       | Same interface for marshalling/unmarshalling as go/json, except with proper serialization of null arrays/maps |
-|             |            |                                                                                                               |
-| bfcodegen   | Mike       | Various codegen tools (run via go generate)                                                                   |
-|             |            |                                                                                                               |
-| rext        | Mike       | Regex Wrapper, wraps regexp with a better interface                                                           |
-| wmo         | Mike       | Mongo Wrapper, wraps mongodb with a better interface                                                          |
-|             |            |                                                                                                               |
-| scn         | Mike       | SimpleCloudNotifier                                                                                           |
-|             |            |                                                                                                               |
-
-
-
-## Usage:
-
-### exerr
-
- - see **mongoext/builder.go** for full info
-
-Short summary:
- - An better error package with metadata, listener, api-output and error-traces
- - Initialize with `exerr.Init()`
- - *Never* return `err` direct, always use exerr.Wrap(err, "...") - add metadata where applicable
- - at the end either Print(), Fatal() or Output() your error (print = stdout, fatal = panic, output = json API response)
- - You can add listeners with exerr.RegisterListener(), and save the full errors to a db or smth
-
-### wmo
-
- - A typed wrapper around the official mongo-go-driver
- - Use `wmo.W[...](...)` to wrap the collections and type-ify them
- - The new collections have all the usual methods, but types
- - Also they have List() and Paginate() methods for paginated listings (witehr with a cursortoken or page/limit)
- - Register additional hooks with `WithDecodeFunc`, `WithUnmarshalHook`, `WithMarshalHook`, `WithModifyingPipeline`, `WithModifyingPipelineFunc`
- - List(), Paginate(), etc support filter interfaces
-   - Rule(s) of thumb: 
-     - filter the results in the filter interface
-     - sort the results in the sort function of the filter interface
-     - add joins ($lookup's) in the `WithModifyingPipelineFunc`/`WithModifyingPipeline`
-
-#### ginext
-
- - A wrapper around gin-gonic/gin
- - create the gin engine with `ginext.NewEngine`
- - Add routes with `engine.Routes()...`
-   - `.Use(..)` adds a middleware
-   - `.Group(..)` adds a group
-   - `.Get().Handle(..)` adds a handler
- - Handler return values (in contract to ginext) - values implement the `ginext.HTTPResponse` interface
- - Every handler starts with something like:
-```go 
-func (handler Handler) CommunityMetricsValues(pctx ginext.PreContext) ginext.HTTPResponse {
-    type communityURI struct {
-        Version     string             `uri:"version"`
-        CommunityID models.CommunityID `uri:"cid"`
-    }
-    type body struct {
-        UserID  models.UserID  `json:"userID"`
-        EventID models.EventID `json:"eventID"`
-    }
-
-    var u uri
-    var b body
-    ctx, gctx, httpErr := pctx.URI(&u).Body(&b).Start() // can have more unmarshaller, like header, form, etc
-    if httpErr != nil {
-    	return *httpErr
-    }
-    defer ctx.Cancel()
-
-    // do stuff
-}
-```
-
-#### sq
-
- - TODO (like mongoext for sqlite/sql databases)

TODO.md

@@ -1,9 +0,0 @@
-
-
- - cronext
-
- - rfctime.HMSTimeOnly
- - rfctime.NanoTimeOnly
-
- - remove sqlx dependency from sq  (unmaintained, and mostly superseeded by our own stuff?)
- - Move DBLogger and DBPreprocessor to sq

_data/version.sh

@@ -7,29 +7,6 @@ set -o pipefail  # Return value of a pipeline is the value of the last (rightmos
 IFS=$'\n\t'      # Set $IFS to only newline and tab.
 
 
-function black() { echo -e "\x1B[30m $1 \x1B[0m"; }
-function red()   { echo -e "\x1B[31m $1 \x1B[0m"; }
-function green() { echo -e "\x1B[32m $1 \x1B[0m"; }
-function yellow(){ echo -e "\x1B[33m $1 \x1B[0m"; }
-function blue()  { echo -e "\x1B[34m $1 \x1B[0m"; }
-function purple(){ echo -e "\x1B[35m $1 \x1B[0m"; }
-function cyan()  { echo -e "\x1B[36m $1 \x1B[0m"; }
-function white() { echo -e "\x1B[37m $1 \x1B[0m"; }
-
-if [ "$( git rev-parse --abbrev-ref HEAD )" != "master" ]; then
-  >&2 red "[ERROR] Can only create versions of <master>"
-  exit 1
-fi
-
-echo ""
-echo -n "Insert optional commit message: "
-read commitMessage
-echo ""
-
-git pull --ff
-
-go get -u ./...
-
 curr_vers=$(git describe --tags --abbrev=0 | sed 's/v//g')
 
 next_ver=$(echo "$curr_vers" | awk -F. -v OFS=. 'NF==1{print ++$NF}; NF>1{if(length($NF+1)>length($NF))$(NF-1)++; $NF=sprintf("%0*d", length($NF), ($NF+1)%(10^length($NF))); print}')
@@ -39,22 +16,9 @@ echo "> Current Version: ${curr_vers}"
 echo "> Next    Version: ${next_ver}"
 echo ""
 
-printf "package goext\n\nconst GoextVersion = \"%s\"\n\nconst GoextVersionTimestamp = \"%s\"\n" "${next_ver}" "$( date +"%Y-%m-%dT%H:%M:%S%z" )" > "goextVersion.go"
-
 git add --verbose .
 
-msg="v${next_ver}"
-
-if [[ "$commitMessage" != "" ]]; then
-  msg="${msg} ${commitMessage}"
-fi
-
-
-if [ $# -gt 0 ]; then
-  msg="$1"
-fi
-
-git commit -a -m "${msg}"
+git commit -a -m "v${next_ver}"
 
 git tag "v${next_ver}"
 

bfcodegen/csid-generate.go

@@ -1,197 +0,0 @@
-package bfcodegen
-
-import (
-	"bytes"
-	_ "embed"
-	"errors"
-	"fmt"
-	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"text/template"
-)
-
-type CSIDDef struct {
-	File         string
-	FileRelative string
-	Name         string
-	Prefix       string
-}
-
-type CSIDGenOptions struct {
-	DebugOutput *bool
-}
-
-var rexCSIDPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
-
-var rexCSIDDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+string\s*//\s*(@csid:type)\s+\[(?P<prefix>[A-Z0-9]{3})].*$`))
-
-var rexCSIDChecksumConst = rext.W(regexp.MustCompile(`const ChecksumCharsetIDGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
-
-//go:embed csid-generate.template
-var templateCSIDGenerateText string
-
-func GenerateCharsetIDSpecs(sourceDir string, destFile string, opt CSIDGenOptions) error {
-
-	debugOutput := langext.Coalesce(opt.DebugOutput, false)
-
-	files, err := os.ReadDir(sourceDir)
-	if err != nil {
-		return err
-	}
-
-	oldChecksum := "N/A"
-	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
-		content, err := os.ReadFile(destFile)
-		if err != nil {
-			return err
-		}
-		if m, ok := rexCSIDChecksumConst.MatchFirst(string(content)); ok {
-			oldChecksum = m.GroupByName("cs").Value()
-		}
-	}
-
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
-	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
-
-	newChecksumStr := goext.GoextVersion
-	for _, f := range files {
-		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
-		if err != nil {
-			return err
-		}
-		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
-	}
-
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
-
-	if newChecksum != oldChecksum {
-		fmt.Printf("[CSIDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
-	} else {
-		fmt.Printf("[CSIDGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
-		return nil
-	}
-
-	allIDs := make([]CSIDDef, 0)
-
-	pkgname := ""
-
-	for _, f := range files {
-		if debugOutput {
-			fmt.Printf("========= %s =========\n\n", f.Name())
-		}
-
-		fileIDs, pn, err := processCSIDFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
-		if err != nil {
-			return err
-		}
-
-		if debugOutput {
-			fmt.Printf("\n")
-		}
-
-		allIDs = append(allIDs, fileIDs...)
-
-		if pn != "" {
-			pkgname = pn
-		}
-	}
-
-	if pkgname == "" {
-		return errors.New("no package name found in any file")
-	}
-
-	fdata, err := format.Source([]byte(fmtCSIDOutput(newChecksum, allIDs, pkgname)))
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(destFile, fdata, 0o755)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func processCSIDFile(basedir string, fn string, debugOutput bool) ([]CSIDDef, string, error) {
-	file, err := os.Open(fn)
-	if err != nil {
-		return nil, "", err
-	}
-
-	defer func() { _ = file.Close() }()
-
-	bin, err := io.ReadAll(file)
-	if err != nil {
-		return nil, "", err
-	}
-
-	lines := strings.Split(string(bin), "\n")
-
-	ids := make([]CSIDDef, 0)
-
-	pkgname := ""
-
-	for i, line := range lines {
-		if i == 0 && strings.HasPrefix(line, "// Code generated by") {
-			break
-		}
-
-		if match, ok := rexCSIDPackage.MatchFirst(line); i == 0 && ok {
-			pkgname = match.GroupByName("name").Value()
-			continue
-		}
-
-		if match, ok := rexCSIDDef.MatchFirst(line); ok {
-
-			rfp, err := filepath.Rel(basedir, fn)
-			if err != nil {
-				return nil, "", err
-			}
-
-			def := CSIDDef{
-				File:         fn,
-				FileRelative: rfp,
-				Name:         match.GroupByName("name").Value(),
-				Prefix:       match.GroupByName("prefix").Value(),
-			}
-
-			if debugOutput {
-				fmt.Printf("Found ID definition { '%s' }\n", def.Name)
-			}
-
-			ids = append(ids, def)
-		}
-	}
-
-	return ids, pkgname, nil
-}
-
-func fmtCSIDOutput(cs string, ids []CSIDDef, pkgname string) string {
-	templ := template.Must(template.New("csid-generate").Parse(templateCSIDGenerateText))
-
-	buffer := bytes.Buffer{}
-
-	err := templ.Execute(&buffer, langext.H{
-		"PkgName":      pkgname,
-		"Checksum":     cs,
-		"GoextVersion": goext.GoextVersion,
-		"IDs":          ids,
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	return buffer.String()
-}

bfcodegen/csid-generate.template

@@ -1,190 +0,0 @@
-// Code generated by csid-generate.go DO NOT EDIT.
-
-package {{.PkgName}}
-
-import "crypto/rand"
-import "crypto/sha256"
-import "fmt"
-import "github.com/go-playground/validator/v10"
-import "github.com/rs/zerolog/log"
-import "gogs.mikescher.com/BlackForestBytes/goext/exerr"
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
-import "gogs.mikescher.com/BlackForestBytes/goext/rext"
-import "math/big"
-import "reflect"
-import "regexp"
-import "strings"
-
-const ChecksumCharsetIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
-
-const idlen = 24
-
-const checklen = 1
-
-const idCharset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-const idCharsetLen = len(idCharset)
-
-var charSetReverseMap = generateCharsetMap()
-
-const ({{range .IDs}}
-	prefix{{.Name}} = "{{.Prefix}}" {{end}}
-)
-
-var ({{range .IDs}}
-	regex{{.Name}} = generateRegex(prefix{{.Name}}) {{end}}
-)
-
-func generateRegex(prefix string) rext.Regex {
-	return rext.W(regexp.MustCompile(fmt.Sprintf("^%s[%s]{%d}[%s]{%d}$", prefix, idCharset, idlen-len(prefix)-checklen, idCharset, checklen)))
-}
-
-func generateCharsetMap() []int {
-	result := make([]int, 128)
-	for i := 0; i < len(result); i++ {
-		result[i] = -1
-	}
-	for idx, chr := range idCharset {
-		result[int(chr)] = idx
-	}
-	return result
-}
-
-func generateID(prefix string) string {
-	k := ""
-	csMax := big.NewInt(int64(idCharsetLen))
-	checksum := 0
-	for i := 0; i < idlen-len(prefix)-checklen; i++ {
-		v, err := rand.Int(rand.Reader, csMax)
-		if err != nil {
-			panic(err)
-		}
-		v64 := v.Int64()
-		k += string(idCharset[v64])
-		checksum = (checksum + int(v64)) % (idCharsetLen)
-	}
-	checkstr := string(idCharset[checksum%idCharsetLen])
-	return prefix + k + checkstr
-}
-
-func generateIDFromSeed(prefix string, seed string) string {
-	h := sha256.New()
-
-	iddata := ""
-	for len(iddata) < idlen-len(prefix)-checklen {
-		h.Write([]byte(seed))
-		bs := h.Sum(nil)
-		iddata += langext.NewAnyBaseConverter(idCharset).Encode(bs)
-	}
-
-	checksum := 0
-	for i := 0; i < idlen-len(prefix)-checklen; i++ {
-		ichr := int(iddata[i])
-		checksum = (checksum + charSetReverseMap[ichr]) % (idCharsetLen)
-	}
-
-	checkstr := string(idCharset[checksum%idCharsetLen])
-
-	return prefix + iddata[:(idlen-len(prefix)-checklen)] + checkstr
-}
-
-func validateID(prefix string, value string) error {
-	if len(value) != idlen {
-		return exerr.New(exerr.TypeInvalidCSID, "id has the wrong length").Str("value", value).Build()
-	}
-
-	if !strings.HasPrefix(value, prefix) {
-		return exerr.New(exerr.TypeInvalidCSID, "id is missing the correct prefix").Str("value", value).Str("prefix", prefix).Build()
-	}
-
-	checksum := 0
-	for i := len(prefix); i < len(value)-checklen; i++ {
-		ichr := int(value[i])
-		if ichr < 0 || ichr >= len(charSetReverseMap) || charSetReverseMap[ichr] == -1 {
-			return exerr.New(exerr.TypeInvalidCSID, "id contains invalid characters").Str("value", value).Build()
-		}
-		checksum = (checksum + charSetReverseMap[ichr]) % (idCharsetLen)
-	}
-
-	checkstr := string(idCharset[checksum%idCharsetLen])
-
-	if !strings.HasSuffix(value, checkstr) {
-		return exerr.New(exerr.TypeInvalidCSID, "id checkstring is invalid").Str("value", value).Str("checkstr", checkstr).Build()
-	}
-
-	return nil
-}
-
-func getRawData(prefix string, value string) string {
-	if len(value) != idlen {
-		return ""
-	}
-	return value[len(prefix) : idlen-checklen]
-}
-
-func getCheckString(prefix string, value string) string {
-	if len(value) != idlen {
-		return ""
-	}
-	return value[idlen-checklen:]
-}
-
-func ValidateEntityID(vfl validator.FieldLevel) bool {
-	if !vfl.Field().CanInterface() {
-		log.Error().Msgf("Failed to validate EntityID (cannot interface ?!?)")
-		return false
-	}
-
-	ifvalue := vfl.Field().Interface()
-
-	if value1, ok := ifvalue.(EntityID); ok {
-
-		if vfl.Field().Type().Kind() == reflect.Pointer && langext.IsNil(value1) {
-			return true
-		}
-
-		if err := value1.Valid(); err != nil {
-			log.Debug().Msgf("Failed to validate EntityID '%s' (%s)", value1.String(), err.Error())
-			return false
-		} else {
-			return true
-		}
-
-	} else {
-		log.Error().Msgf("Failed to validate EntityID (wrong type: %T)", ifvalue)
-		return false
-	}
-}
-
-{{range .IDs}}
-
-// ================================ {{.Name}} ({{.FileRelative}}) ================================
-
-func New{{.Name}}() {{.Name}} {
-	return {{.Name}}(generateID(prefix{{.Name}}))
-}
-
-func (id {{.Name}}) Valid() error {
-	return validateID(prefix{{.Name}}, string(id))
-}
-
-func (i {{.Name}}) String() string {
-	return string(i)
-}
-
-func (i {{.Name}}) Prefix() string {
-	return prefix{{.Name}}
-}
-
-func (id {{.Name}}) Raw() string {
-	return getRawData(prefix{{.Name}}, string(id))
-}
-
-func (id {{.Name}}) CheckString() string {
-	return getCheckString(prefix{{.Name}}, string(id))
-}
-
-func (id {{.Name}}) Regex() rext.Regex {
-	return regex{{.Name}}
-}
-
-{{end}}

bfcodegen/csid-generate_test.go

@@ -1,52 +0,0 @@
-package bfcodegen
-
-import (
-	_ "embed"
-	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-//go:embed _test_example_1.tgz
-var CSIDExampleModels1 []byte
-
-func TestGenerateCSIDSpecs(t *testing.T) {
-
-	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
-
-	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
-
-	err := os.WriteFile(tmpFile, CSIDExampleModels1, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.Remove(tmpFile) })
-
-	err = os.Mkdir(tmpDir, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
-
-	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
-	tst.AssertNoErr(t, err)
-
-	err = GenerateCharsetIDSpecs(tmpDir, tmpDir+"/csid_gen.go", CSIDGenOptions{DebugOutput: langext.PTrue})
-	tst.AssertNoErr(t, err)
-
-	err = GenerateCharsetIDSpecs(tmpDir, tmpDir+"/csid_gen.go", CSIDGenOptions{DebugOutput: langext.PTrue})
-	tst.AssertNoErr(t, err)
-
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-	fmt.Println("=====================================================================================================")
-	fmt.Println(string(tst.Must(os.ReadFile(tmpDir + "/csid_gen.go"))(t)))
-	fmt.Println("=====================================================================================================")
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-}

bfcodegen/enum-generate.go

@@ -1,373 +0,0 @@
-package bfcodegen
-
-import (
-	"bytes"
-	_ "embed"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"regexp"
-	"strings"
-	"text/template"
-)
-
-type EnumDefVal struct {
-	VarName     string
-	Value       string
-	Description *string
-	Data        *map[string]any
-	RawComment  *string
-}
-
-type EnumDef struct {
-	File         string
-	FileRelative string
-	EnumTypeName string
-	Type         string
-	Values       []EnumDefVal
-}
-
-type EnumGenOptions struct {
-	DebugOutput *bool
-	GoFormat    *bool
-}
-
-var rexEnumPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
-
-var rexEnumDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*//\s*(@enum:type).*$`))
-
-var rexEnumValueDef = rext.W(regexp.MustCompile(`^\s*(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*=\s*(?P<value>("[A-Za-z0-9_:\s\-.]*"|[0-9]+))\s*(//(?P<comm>.*))?.*$`))
-
-var rexEnumChecksumConst = rext.W(regexp.MustCompile(`const ChecksumEnumGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
-
-//go:embed enum-generate.template
-var templateEnumGenerateText string
-
-func GenerateEnumSpecs(sourceDir string, destFile string, opt EnumGenOptions) error {
-
-	oldChecksum := "N/A"
-	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
-		content, err := os.ReadFile(destFile)
-		if err != nil {
-			return err
-		}
-		if m, ok := rexEnumChecksumConst.MatchFirst(string(content)); ok {
-			oldChecksum = m.GroupByName("cs").Value()
-		}
-	}
-
-	gocode, _, changed, err := _generateEnumSpecs(sourceDir, destFile, oldChecksum, langext.Coalesce(opt.GoFormat, true), langext.Coalesce(opt.DebugOutput, false))
-	if err != nil {
-		return err
-	}
-
-	if !changed {
-		return nil
-	}
-
-	err = os.WriteFile(destFile, []byte(gocode), 0o755)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func _generateEnumSpecs(sourceDir string, destFile string, oldChecksum string, gofmt bool, debugOutput bool) (string, string, bool, error) {
-
-	files, err := os.ReadDir(sourceDir)
-	if err != nil {
-		return "", "", false, err
-	}
-
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
-	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
-
-	newChecksumStr := goext.GoextVersion
-	for _, f := range files {
-		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
-		if err != nil {
-			return "", "", false, err
-		}
-		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
-	}
-
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
-
-	if newChecksum != oldChecksum {
-		fmt.Printf("[EnumGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
-	} else {
-		fmt.Printf("[EnumGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
-		return "", oldChecksum, false, nil
-	}
-
-	allEnums := make([]EnumDef, 0)
-
-	pkgname := ""
-
-	for _, f := range files {
-		if debugOutput {
-			fmt.Printf("========= %s =========\n\n", f.Name())
-		}
-
-		fileEnums, pn, err := processEnumFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
-		if err != nil {
-			return "", "", false, err
-		}
-
-		if debugOutput {
-			fmt.Printf("\n")
-		}
-
-		allEnums = append(allEnums, fileEnums...)
-
-		if pn != "" {
-			pkgname = pn
-		}
-	}
-
-	if pkgname == "" {
-		return "", "", false, errors.New("no package name found in any file")
-	}
-
-	rdata := fmtEnumOutput(newChecksum, allEnums, pkgname)
-
-	if !gofmt {
-		return rdata, newChecksum, true, nil
-	}
-
-	fdata, err := format.Source([]byte(rdata))
-	if err != nil {
-		return "", "", false, err
-	}
-
-	return string(fdata), newChecksum, true, nil
-}
-
-func processEnumFile(basedir string, fn string, debugOutput bool) ([]EnumDef, string, error) {
-	file, err := os.Open(fn)
-	if err != nil {
-		return nil, "", err
-	}
-
-	defer func() { _ = file.Close() }()
-
-	bin, err := io.ReadAll(file)
-	if err != nil {
-		return nil, "", err
-	}
-
-	lines := strings.Split(string(bin), "\n")
-
-	enums := make([]EnumDef, 0)
-
-	pkgname := ""
-
-	for i, line := range lines {
-		if i == 0 && strings.HasPrefix(line, "// Code generated by") {
-			break
-		}
-
-		if match, ok := rexEnumPackage.MatchFirst(line); i == 0 && ok {
-			pkgname = match.GroupByName("name").Value()
-			continue
-		}
-
-		if match, ok := rexEnumDef.MatchFirst(line); ok {
-
-			rfp, err := filepath.Rel(basedir, fn)
-			if err != nil {
-				return nil, "", err
-			}
-
-			def := EnumDef{
-				File:         fn,
-				FileRelative: rfp,
-				EnumTypeName: match.GroupByName("name").Value(),
-				Type:         match.GroupByName("type").Value(),
-				Values:       make([]EnumDefVal, 0),
-			}
-			enums = append(enums, def)
-
-			if debugOutput {
-				fmt.Printf("Found enum definition { '%s' -> '%s' }\n", def.EnumTypeName, def.Type)
-			}
-		}
-
-		if match, ok := rexEnumValueDef.MatchFirst(line); ok {
-			typename := match.GroupByName("type").Value()
-
-			comment := match.GroupByNameOrEmpty("comm").ValueOrNil()
-			var descr *string = nil
-			var data *map[string]any = nil
-			if comment != nil {
-				comment = langext.Ptr(strings.TrimSpace(*comment))
-				if strings.HasPrefix(*comment, "{") {
-					if v, ok := tryParseDataComment(*comment); ok {
-						data = &v
-						if anyDataDescr, ok := v["description"]; ok {
-							if dataDescr, ok := anyDataDescr.(string); ok {
-								descr = &dataDescr
-							}
-						}
-					} else {
-						descr = comment
-					}
-				} else {
-					descr = comment
-				}
-			}
-
-			def := EnumDefVal{
-				VarName:     match.GroupByName("name").Value(),
-				Value:       match.GroupByName("value").Value(),
-				RawComment:  comment,
-				Description: descr,
-				Data:        data,
-			}
-
-			found := false
-			for i, v := range enums {
-				if v.EnumTypeName == typename {
-					enums[i].Values = append(enums[i].Values, def)
-					found = true
-
-					if debugOutput {
-						if def.Description != nil {
-							fmt.Printf("Found enum value [%s] for '%s'  ('%s')\n", def.Value, def.VarName, *def.Description)
-						} else {
-							fmt.Printf("Found enum value [%s] for '%s'\n", def.Value, def.VarName)
-						}
-					}
-					break
-				}
-			}
-			if !found {
-				if debugOutput {
-					fmt.Printf("Found non-enum value [%s] for '%s' ( looks like enum value, but no matching @enum:type )\n", def.Value, def.VarName)
-				}
-			}
-		}
-	}
-
-	return enums, pkgname, nil
-}
-
-func tryParseDataComment(s string) (map[string]any, bool) {
-
-	r := make(map[string]any)
-
-	err := json.Unmarshal([]byte(s), &r)
-	if err != nil {
-		return nil, false
-	}
-
-	for _, v := range r {
-
-		rv := reflect.ValueOf(v)
-
-		if rv.Kind() == reflect.Ptr && rv.IsNil() {
-			continue
-		}
-		if rv.Kind() == reflect.Bool {
-			continue
-		}
-		if rv.Kind() == reflect.String {
-			continue
-		}
-		if rv.Kind() == reflect.Int64 {
-			continue
-		}
-		if rv.Kind() == reflect.Float64 {
-			continue
-		}
-
-		return nil, false
-	}
-
-	return r, true
-}
-
-func fmtEnumOutput(cs string, enums []EnumDef, pkgname string) string {
-
-	templ := template.New("enum-generate")
-
-	templ = templ.Funcs(template.FuncMap{
-		"boolToStr": func(b bool) string { return langext.Conditional(b, "true", "false") },
-		"deref":     func(v *string) string { return *v },
-		"trimSpace": func(str string) string { return strings.TrimSpace(str) },
-		"hasStr":    func(v EnumDef) bool { return v.Type == "string" },
-		"hasDescr": func(v EnumDef) bool {
-			return langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Description != nil })
-		},
-		"hasData": func(v EnumDef) bool {
-			return len(v.Values) > 0 && langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Data != nil })
-		},
-		"gostr": func(v any) string {
-			return fmt.Sprintf("%#+v", v)
-		},
-		"goobj": func(name string, v any) string {
-			return fmt.Sprintf("%#+v", v)
-		},
-		"godatakey": func(v string) string {
-			return strings.ToUpper(v[0:1]) + v[1:]
-		},
-		"godatavalue": func(v any) string {
-			return fmt.Sprintf("%#+v", v)
-		},
-		"godatatype": func(v any) string {
-			return fmt.Sprintf("%T", v)
-		},
-		"mapindex": func(v map[string]any, k string) any {
-			return v[k]
-		},
-		"generalDataKeys": func(v EnumDef) map[string]string {
-			r0 := make(map[string]int)
-
-			for _, eval := range v.Values {
-				for k := range *eval.Data {
-					if ctr, ok := r0[k]; ok {
-						r0[k] = ctr + 1
-					} else {
-						r0[k] = 1
-					}
-				}
-			}
-
-			r1 := langext.MapToArr(r0)
-			r2 := langext.ArrFilter(r1, func(p langext.MapEntry[string, int]) bool { return p.Value == len(v.Values) })
-			r3 := langext.ArrMap(r2, func(p langext.MapEntry[string, int]) string { return p.Key })
-			r4 := langext.ArrToKVMap(r3, func(p string) string { return p }, func(p string) string { return fmt.Sprintf("%T", (*v.Values[0].Data)[p]) })
-
-			return r4
-		},
-	})
-
-	templ = template.Must(templ.Parse(templateEnumGenerateText))
-
-	buffer := bytes.Buffer{}
-
-	err := templ.Execute(&buffer, langext.H{
-		"PkgName":      pkgname,
-		"Checksum":     cs,
-		"GoextVersion": goext.GoextVersion,
-		"Enums":        enums,
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	return buffer.String()
-}

bfcodegen/enum-generate.template

@@ -1,155 +0,0 @@
-// Code generated by enum-generate.go DO NOT EDIT.
-
-package {{.PkgName}}
-
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
-import "gogs.mikescher.com/BlackForestBytes/goext/enums"
-
-const ChecksumEnumGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
-
-{{ $pkgname  := .PkgName }}
-
-{{range .Enums}}
-
-{{ $hasStr   := ( . | hasStr   ) }}
-{{ $hasDescr := ( . | hasDescr ) }}
-{{ $hasData  := ( . | hasData  ) }}
-
-// ================================ {{.EnumTypeName}} ================================
-//
-// File:       {{.FileRelative}}
-// StringEnum: {{$hasStr   | boolToStr}}
-// DescrEnum:  {{$hasDescr | boolToStr}}
-// DataEnum:   {{$hasData  | boolToStr}}
-//
-
-{{ $typename := .EnumTypeName }}
-{{ $enumdef  := . }}
-
-var __{{.EnumTypeName}}Values = []{{.EnumTypeName}}{ {{range .Values}}
-	{{.VarName}}, {{end}}
-}
-
-{{if $hasDescr}}
-var __{{.EnumTypeName}}Descriptions = map[{{.EnumTypeName}}]string{ {{range .Values}}
-	{{.VarName}}: {{.Description | deref | trimSpace | gostr}}, {{end}}
-}
-{{end}}
-
-{{if $hasData}}
-type {{ .EnumTypeName }}Data struct { {{ range $datakey, $datatype := ($enumdef | generalDataKeys)  }}
-    {{ $datakey | godatakey }} {{ $datatype }} `json:"{{ $datakey }}"` {{ end }}
-}
-
-var __{{.EnumTypeName}}Data = map[{{.EnumTypeName}}]{{.EnumTypeName}}Data{ {{range .Values}} {{ $enumvalue := . }}
-	{{.VarName}}: {{ $typename }}Data{ {{ range $datakey, $datatype := $enumdef | generalDataKeys  }}
-	    {{ $datakey | godatakey }}: {{ (mapindex $enumvalue.Data $datakey) | godatavalue }}, {{ end }}
-	}, {{end}}
-}
-{{end}}
-
-var __{{.EnumTypeName}}Varnames = map[{{.EnumTypeName}}]string{ {{range .Values}}
-	{{.VarName}}: "{{.VarName}}", {{end}}
-}
-
-func (e {{.EnumTypeName}}) Valid() bool {
-	return langext.InArray(e, __{{.EnumTypeName}}Values)
-}
-
-func (e {{.EnumTypeName}}) Values() []{{.EnumTypeName}} {
-	return __{{.EnumTypeName}}Values
-}
-
-func (e {{.EnumTypeName}}) ValuesAny() []any {
-	return langext.ArrCastToAny(__{{.EnumTypeName}}Values)
-}
-
-func (e {{.EnumTypeName}}) ValuesMeta() []enums.EnumMetaValue {
-	return {{.EnumTypeName}}ValuesMeta()
-}
-
-{{if $hasStr}}
-func (e {{.EnumTypeName}}) String() string {
-	return string(e)
-}
-{{end}}
-
-{{if $hasDescr}}
-func (e {{.EnumTypeName}}) Description() string {
-	if d, ok := __{{.EnumTypeName}}Descriptions[e]; ok {
-		return d
-	}
-	return ""
-}
-{{end}}
-
-{{if $hasData}}
-func (e {{.EnumTypeName}}) Data() {{.EnumTypeName}}Data {
-	if d, ok := __{{.EnumTypeName}}Data[e]; ok {
-		return d
-	}
-	return {{.EnumTypeName}}Data{}
-}
-{{end}}
-
-func (e {{.EnumTypeName}}) VarName() string {
-	if d, ok := __{{.EnumTypeName}}Varnames[e]; ok {
-		return d
-	}
-	return ""
-}
-
-func (e {{.EnumTypeName}}) TypeName() string {
-	return "{{$typename}}"
-}
-
-func (e {{.EnumTypeName}}) PackageName() string {
-	return "{{$pkgname }}"
-}
-
-func (e {{.EnumTypeName}}) Meta() enums.EnumMetaValue {
-    {{if $hasDescr}} return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: langext.Ptr(e.Description())} {{else}} return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil} {{end}}
-}
-
-{{if $hasDescr}}
-func (e {{.EnumTypeName}}) DescriptionMeta() enums.EnumDescriptionMetaValue {
-    return enums.EnumDescriptionMetaValue{VarName: e.VarName(), Value: e, Description: e.Description()}
-}
-{{end}}
-
-func Parse{{.EnumTypeName}}(vv string) ({{.EnumTypeName}}, bool) {
-	for _, ev := range __{{.EnumTypeName}}Values {
-		if string(ev) == vv {
-			return ev, true
-		}
-	}
-	return "", false
-}
-
-func {{.EnumTypeName}}Values() []{{.EnumTypeName}} {
-	return __{{.EnumTypeName}}Values
-}
-
-func {{.EnumTypeName}}ValuesMeta() []enums.EnumMetaValue {
-	return []enums.EnumMetaValue{ {{range .Values}}
-            {{.VarName}}.Meta(), {{end}}
-	}
-}
-
-{{if $hasDescr}}
-func {{.EnumTypeName}}ValuesDescriptionMeta() []enums.EnumDescriptionMetaValue {
-	return []enums.EnumDescriptionMetaValue{ {{range .Values}}
-            {{.VarName}}.DescriptionMeta(), {{end}}
-	}
-}
-{{end}}
-
-{{end}}
-
-// ================================ ================= ================================
-
-func AllPackageEnums() []enums.Enum {
-    return []enums.Enum{ {{range .Enums}}
-        {{ if gt (len .Values) 0 }} {{  $v := index .Values 0 }} {{ $v.VarName}}, {{end}} // {{ .EnumTypeName }} {{end}}
-    }
-}

bfcodegen/enum-generate_test.go

@@ -1,91 +0,0 @@
-package bfcodegen
-
-import (
-	_ "embed"
-	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-//go:embed _test_example_1.tgz
-var EnumExampleModels1 []byte
-
-//go:embed _test_example_2.tgz
-var EnumExampleModels2 []byte
-
-func TestGenerateEnumSpecs(t *testing.T) {
-
-	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
-
-	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
-
-	err := os.WriteFile(tmpFile, EnumExampleModels1, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.Remove(tmpFile) })
-
-	err = os.Mkdir(tmpDir, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
-
-	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
-	tst.AssertNoErr(t, err)
-
-	s1, cs1, _, err := _generateEnumSpecs(tmpDir, "", "N/A", true, true)
-	tst.AssertNoErr(t, err)
-
-	s2, cs2, _, err := _generateEnumSpecs(tmpDir, "", "N/A", true, true)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertEqual(t, cs1, cs2)
-	tst.AssertEqual(t, s1, s2)
-
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-	fmt.Println("=====================================================================================================")
-	fmt.Println(s1)
-	fmt.Println("=====================================================================================================")
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-}
-
-func TestGenerateEnumSpecsData(t *testing.T) {
-
-	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
-
-	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
-
-	err := os.WriteFile(tmpFile, EnumExampleModels2, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.Remove(tmpFile) })
-
-	err = os.Mkdir(tmpDir, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
-
-	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
-	tst.AssertNoErr(t, err)
-
-	s1, _, _, err := _generateEnumSpecs(tmpDir, "", "", true, true)
-	tst.AssertNoErr(t, err)
-
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-	fmt.Println("=====================================================================================================")
-	fmt.Println(s1)
-	fmt.Println("=====================================================================================================")
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-}

bfcodegen/id-generate.go

@@ -1,198 +0,0 @@
-package bfcodegen
-
-import (
-	"bytes"
-	_ "embed"
-	"errors"
-	"fmt"
-	"go/format"
-	"gogs.mikescher.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"text/template"
-)
-
-type IDDef struct {
-	File         string
-	FileRelative string
-	Name         string
-}
-
-type IDGenOptions struct {
-	DebugOutput *bool
-}
-
-var rexIDPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
-
-var rexIDDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+string\s*//\s*(@id:type).*$`))
-
-var rexIDChecksumConst = rext.W(regexp.MustCompile(`const ChecksumIDGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
-
-//go:embed id-generate.template
-var templateIDGenerateText string
-
-func GenerateIDSpecs(sourceDir string, destFile string, opt IDGenOptions) error {
-
-	debugOutput := langext.Coalesce(opt.DebugOutput, false)
-
-	files, err := os.ReadDir(sourceDir)
-	if err != nil {
-		return err
-	}
-
-	oldChecksum := "N/A"
-	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
-		content, err := os.ReadFile(destFile)
-		if err != nil {
-			return err
-		}
-		if m, ok := rexIDChecksumConst.MatchFirst(string(content)); ok {
-			oldChecksum = m.GroupByName("cs").Value()
-		}
-	}
-
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
-	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
-	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
-
-	newChecksumStr := goext.GoextVersion
-	for _, f := range files {
-		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
-		if err != nil {
-			return err
-		}
-		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
-	}
-
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
-
-	if newChecksum != oldChecksum {
-		fmt.Printf("[IDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
-	} else {
-		fmt.Printf("[IDGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
-		return nil
-	}
-
-	allIDs := make([]IDDef, 0)
-
-	pkgname := ""
-
-	for _, f := range files {
-		if debugOutput {
-			fmt.Printf("========= %s =========\n\n", f.Name())
-		}
-
-		fileIDs, pn, err := processIDFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
-		if err != nil {
-			return err
-		}
-
-		if debugOutput {
-			fmt.Printf("\n")
-		}
-
-		allIDs = append(allIDs, fileIDs...)
-
-		if pn != "" {
-			pkgname = pn
-		}
-	}
-
-	if pkgname == "" {
-		return errors.New("no package name found in any file")
-	}
-
-	fdata, err := format.Source([]byte(fmtIDOutput(newChecksum, allIDs, pkgname)))
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(destFile, fdata, 0o755)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func processIDFile(basedir string, fn string, debugOutput bool) ([]IDDef, string, error) {
-	file, err := os.Open(fn)
-	if err != nil {
-		return nil, "", err
-	}
-
-	defer func() { _ = file.Close() }()
-
-	bin, err := io.ReadAll(file)
-	if err != nil {
-		return nil, "", err
-	}
-
-	lines := strings.Split(string(bin), "\n")
-
-	ids := make([]IDDef, 0)
-
-	pkgname := ""
-
-	for i, line := range lines {
-		if i == 0 && strings.HasPrefix(line, "// Code generated by") {
-			break
-		}
-
-		if match, ok := rexIDPackage.MatchFirst(line); i == 0 && ok {
-			pkgname = match.GroupByName("name").Value()
-			continue
-		}
-
-		if match, ok := rexIDDef.MatchFirst(line); ok {
-
-			rfp, err := filepath.Rel(basedir, fn)
-			if err != nil {
-				return nil, "", err
-			}
-
-			def := IDDef{
-				File:         fn,
-				FileRelative: rfp,
-				Name:         match.GroupByName("name").Value(),
-			}
-
-			if debugOutput {
-				fmt.Printf("Found ID definition { '%s' }\n", def.Name)
-			}
-
-			ids = append(ids, def)
-		}
-	}
-
-	return ids, pkgname, nil
-}
-
-func fmtIDOutput(cs string, ids []IDDef, pkgname string) string {
-	templ := template.Must(template.New("id-generate").Parse(templateIDGenerateText))
-
-	buffer := bytes.Buffer{}
-
-	anyDef := langext.ArrFirstOrNil(ids, func(def IDDef) bool { return def.Name == "AnyID" || def.Name == "AnyId" })
-
-	err := templ.Execute(&buffer, langext.H{
-		"PkgName":      pkgname,
-		"Checksum":     cs,
-		"GoextVersion": goext.GoextVersion,
-		"IDs":          ids,
-		"AnyDef":       anyDef,
-	})
-	if err != nil {
-		panic(err)
-	}
-
-	return buffer.String()
-}

bfcodegen/id-generate.template

@@ -1,47 +0,0 @@
-// Code generated by id-generate.go DO NOT EDIT.
-
-package {{.PkgName}}
-
-import "go.mongodb.org/mongo-driver/bson"
-import "go.mongodb.org/mongo-driver/bson/bsontype"
-import "go.mongodb.org/mongo-driver/bson/primitive"
-import "gogs.mikescher.com/BlackForestBytes/goext/exerr"
-
-const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
-
-{{range .IDs}}
-
-// ================================ {{.Name}} ({{.FileRelative}}) ================================
-
-func (i {{.Name}}) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	if objId, err := primitive.ObjectIDFromHex(string(i)); err == nil {
-		return bson.MarshalValue(objId)
-	} else {
-		return 0, nil, exerr.New(exerr.TypeMarshalEntityID, "Failed to marshal {{.Name}}("+i.String()+") to ObjectId").Str("value", string(i)).Type("type", i).Build()
-	}
-}
-
-func (i {{.Name}}) String() string {
-	return string(i)
-}
-
-func (i {{.Name}}) ObjID() (primitive.ObjectID, error) {
-	return primitive.ObjectIDFromHex(string(i))
-}
-
-func (i {{.Name}}) Valid() bool {
-	_, err := primitive.ObjectIDFromHex(string(i))
-	return err == nil
-}
-
-{{if ne $.AnyDef nil}}
-func (i {{.Name}}) AsAny() {{$.AnyDef.Name}} {
-	return {{$.AnyDef.Name}}(i)
-}
-{{end}}
-
-func New{{.Name}}() {{.Name}} {
-	return {{.Name}}(primitive.NewObjectID().Hex())
-}
-
-{{end}}

bfcodegen/id-generate_test.go

@@ -1,52 +0,0 @@
-package bfcodegen
-
-import (
-	_ "embed"
-	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-//go:embed _test_example_1.tgz
-var IDExampleModels1 []byte
-
-func TestGenerateIDSpecs(t *testing.T) {
-
-	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
-
-	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
-
-	err := os.WriteFile(tmpFile, IDExampleModels1, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.Remove(tmpFile) })
-
-	err = os.Mkdir(tmpDir, 0o777)
-	tst.AssertNoErr(t, err)
-
-	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
-
-	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
-	tst.AssertNoErr(t, err)
-
-	err = GenerateIDSpecs(tmpDir, tmpDir+"/id_gen.go", IDGenOptions{DebugOutput: langext.PTrue})
-	tst.AssertNoErr(t, err)
-
-	err = GenerateIDSpecs(tmpDir, tmpDir+"/id_gen.go", IDGenOptions{DebugOutput: langext.PTrue})
-	tst.AssertNoErr(t, err)
-
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-	fmt.Println("=====================================================================================================")
-	fmt.Println(string(tst.Must(os.ReadFile(tmpDir + "/id_gen.go"))(t)))
-	fmt.Println("=====================================================================================================")
-	fmt.Println()
-	fmt.Println()
-	fmt.Println()
-}

cmdext/builder.go

@@ -2,7 +2,6 @@ package cmdext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -12,9 +11,6 @@ type CommandRunner struct {
 	timeout  *time.Duration
 	env      []string
 	listener []CommandListener
-	enforceExitCodes *[]int
-	enforceNoTimeout bool
-	enforceNoStderr  bool
 }
 
 func Runner(program string) *CommandRunner {
@@ -24,9 +20,6 @@ func Runner(program string) *CommandRunner {
 		timeout:  nil,
 		env:      make([]string, 0),
 		listener: make([]CommandListener, 0),
-		enforceExitCodes: nil,
-		enforceNoTimeout: false,
-		enforceNoStderr:  false,
 	}
 }
 
@@ -60,26 +53,6 @@ func (r *CommandRunner) Envs(env []string) *CommandRunner {
 	return r
 }
 
-func (r *CommandRunner) EnsureExitcode(arg ...int) *CommandRunner {
-	r.enforceExitCodes = langext.Ptr(langext.ForceArray(arg))
-	return r
-}
-
-func (r *CommandRunner) FailOnExitCode() *CommandRunner {
-	r.enforceExitCodes = langext.Ptr([]int{0})
-	return r
-}
-
-func (r *CommandRunner) FailOnTimeout() *CommandRunner {
-	r.enforceNoTimeout = true
-	return r
-}
-
-func (r *CommandRunner) FailOnStderr() *CommandRunner {
-	r.enforceNoStderr = true
-	return r
-}
-
 func (r *CommandRunner) Listen(lstr CommandListener) *CommandRunner {
 	r.listener = append(r.listener, lstr)
 	return r

cmdext/cmdrunner.go

@@ -1,18 +1,12 @@
 package cmdext
 
 import (
-	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
 	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
 	"os/exec"
 	"time"
 )
 
-var ErrExitCode = errors.New("process exited with an unexpected exitcode")
-var ErrTimeout = errors.New("process did not exit after the specified timeout")
-var ErrStderrPrint = errors.New("process did print to stderr stream")
-
 type CommandResult struct {
 	StdOut          string
 	StdErr          string
@@ -37,7 +31,6 @@ func run(opt CommandRunner) (CommandResult, error) {
 	}
 
 	preader := pipeReader{
-		lineBufferSize: langext.Ptr(128 * 1024 * 1024), // 128MB max size of a single line, is hopefully enough....
 		stdout: stdoutPipe,
 		stderr: stderrPipe,
 	}
@@ -54,40 +47,22 @@ func run(opt CommandRunner) (CommandResult, error) {
 		err         error
 	}
 
-	stderrFailChan := make(chan bool)
-
 	outputChan := make(chan resultObj)
 	go func() {
 		// we need to first fully read the pipes and then call Wait
 		// see https://pkg.go.dev/os/exec#Cmd.StdoutPipe
 
-		listener := make([]CommandListener, 0)
-		listener = append(listener, opt.listener...)
-
-		if opt.enforceNoStderr {
-			listener = append(listener, genericCommandListener{
-				_readRawStderr: langext.Ptr(func(v []byte) {
-					if len(v) > 0 {
-						stderrFailChan <- true
-					}
-				}),
-			})
-		}
-
-		stdout, stderr, stdcombined, err := preader.Read(listener)
+		stdout, stderr, stdcombined, err := preader.Read(opt.listener)
 		if err != nil {
 			outputChan <- resultObj{stdout, stderr, stdcombined, err}
-			_ = cmd.Process.Kill()
-			return
 		}
 
 		err = cmd.Wait()
 		if err != nil {
 			outputChan <- resultObj{stdout, stderr, stdcombined, err}
-		} else {
-			outputChan <- resultObj{stdout, stderr, stdcombined, nil}
 		}
 
+		outputChan <- resultObj{stdout, stderr, stdcombined, nil}
 	}()
 
 	var timeoutChan <-chan time.Time = make(chan time.Time, 1)
@@ -106,91 +81,49 @@ func run(opt CommandRunner) (CommandResult, error) {
 		if fallback, ok := syncext.ReadChannelWithTimeout(outputChan, mathext.Min(32*time.Millisecond, *opt.timeout)); ok {
 			// most of the time the cmd.Process.Kill() should also ahve finished the pipereader
 			// and we can at least return the already collected stdout, stderr, etc
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          fallback.stdout,
 				StdErr:          fallback.stderr,
 				StdCombined:     fallback.stdcombined,
 				ExitCode:        -1,
 				CommandTimedOut: true,
-			}
-			if opt.enforceNoTimeout {
-				return res, ErrTimeout
-			}
-			return res, nil
+			}, nil
 		} else {
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          "",
 				StdErr:          "",
 				StdCombined:     "",
 				ExitCode:        -1,
 				CommandTimedOut: true,
-			}
-			if opt.enforceNoTimeout {
-				return res, ErrTimeout
-			}
-			return res, nil
-		}
-
-	case <-stderrFailChan:
-		_ = cmd.Process.Kill()
-
-		if fallback, ok := syncext.ReadChannelWithTimeout(outputChan, 32*time.Millisecond); ok {
-			// most of the time the cmd.Process.Kill() should also have finished the pipereader
-			// and we can at least return the already collected stdout, stderr, etc
-			res := CommandResult{
-				StdOut:          fallback.stdout,
-				StdErr:          fallback.stderr,
-				StdCombined:     fallback.stdcombined,
-				ExitCode:        -1,
-				CommandTimedOut: false,
-			}
-			return res, ErrStderrPrint
-		} else {
-			res := CommandResult{
-				StdOut:          "",
-				StdErr:          "",
-				StdCombined:     "",
-				ExitCode:        -1,
-				CommandTimedOut: false,
-			}
-			return res, ErrStderrPrint
+			}, nil
 		}
 
 	case outobj := <-outputChan:
-		var exiterr *exec.ExitError
-		if errors.As(outobj.err, &exiterr) {
+		if exiterr, ok := outobj.err.(*exec.ExitError); ok {
 			excode := exiterr.ExitCode()
 			for _, lstr := range opt.listener {
 				lstr.Finished(excode)
 			}
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          outobj.stdout,
 				StdErr:          outobj.stderr,
 				StdCombined:     outobj.stdcombined,
 				ExitCode:        excode,
 				CommandTimedOut: false,
-			}
-			if opt.enforceExitCodes != nil && !langext.InArray(excode, *opt.enforceExitCodes) {
-				return res, ErrExitCode
-			}
-			return res, nil
+			}, nil
 		} else if err != nil {
 			return CommandResult{}, err
 		} else {
 			for _, lstr := range opt.listener {
 				lstr.Finished(0)
 			}
-			res := CommandResult{
+			return CommandResult{
 				StdOut:          outobj.stdout,
 				StdErr:          outobj.stderr,
 				StdCombined:     outobj.stdcombined,
 				ExitCode:        0,
 				CommandTimedOut: false,
-			}
-			if opt.enforceExitCodes != nil && !langext.InArray(0, *opt.enforceExitCodes) {
-				return res, ErrExitCode
-			}
-			return res, nil
+			}, nil
 		}
 	}
 }

cmdext/cmdrunner_test.go

@@ -1,7 +1,6 @@
 package cmdext
 
 import (
-	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -13,12 +12,6 @@ func TestStdout(t *testing.T) {
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -33,16 +26,10 @@ func TestStdout(t *testing.T) {
 
 func TestStderr(t *testing.T) {
 
-	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").Run()
+	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "error" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -56,19 +43,13 @@ func TestStderr(t *testing.T) {
 }
 
 func TestStdcombined(t *testing.T) {
-	res1, err := Runner("python3").
+	res1, err := Runner("python").
 		Arg("-c").
 		Arg("import sys; import time; print(\"1\", file=sys.stderr, flush=True); time.sleep(0.1); print(\"2\", file=sys.stdout, flush=True); time.sleep(0.1); print(\"3\", file=sys.stderr, flush=True)").
 		Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "1\n3\n" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -82,7 +63,7 @@ func TestStdcombined(t *testing.T) {
 }
 
 func TestPartialRead(t *testing.T) {
-	res1, err := Runner("python3").
+	res1, err := Runner("python").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", flush=True); time.sleep(5); print(\"cant see me\", flush=True);").
 		Timeout(100 * time.Millisecond).
@@ -106,7 +87,7 @@ func TestPartialRead(t *testing.T) {
 }
 
 func TestPartialReadStderr(t *testing.T) {
-	res1, err := Runner("python3").
+	res1, err := Runner("python").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", file=sys.stderr, flush=True); time.sleep(5); print(\"cant see me\", file=sys.stderr, flush=True);").
 		Timeout(100 * time.Millisecond).
@@ -131,16 +112,10 @@ func TestPartialReadStderr(t *testing.T) {
 
 func TestReadUnflushedStdout(t *testing.T) {
 
-	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stdout, end='')").Run()
+	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stdout, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -155,16 +130,10 @@ func TestReadUnflushedStdout(t *testing.T) {
 
 func TestReadUnflushedStderr(t *testing.T) {
 
-	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stderr, end='')").Run()
+	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stderr, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
 	if res1.StdErr != "message101" {
 		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
 	}
@@ -180,7 +149,7 @@ func TestReadUnflushedStderr(t *testing.T) {
 func TestPartialReadUnflushed(t *testing.T) {
 	t.SkipNow()
 
-	res1, err := Runner("python3").
+	res1, err := Runner("python").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", end=''); time.sleep(5); print(\"cant see me\", end='');").
 		Timeout(100 * time.Millisecond).
@@ -206,7 +175,7 @@ func TestPartialReadUnflushed(t *testing.T) {
 func TestPartialReadUnflushedStderr(t *testing.T) {
 	t.SkipNow()
 
-	res1, err := Runner("python3").
+	res1, err := Runner("python").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", file=sys.stderr, end=''); time.sleep(5); print(\"cant see me\", file=sys.stderr, end='');").
 		Timeout(100 * time.Millisecond).
@@ -231,7 +200,7 @@ func TestPartialReadUnflushedStderr(t *testing.T) {
 
 func TestListener(t *testing.T) {
 
-	res1, err := Runner("python3").
+	_, err := Runner("python").
 		Arg("-c").
 		Arg("import sys;" +
 			"import time;" +
@@ -254,95 +223,4 @@ func TestListener(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
-}
-
-func TestLongStdout(t *testing.T) {
-
-	res1, err := Runner("python3").
-		Arg("-c").
-		Arg("import sys; import time; print(\"X\" * 125001 + \"\\n\"); print(\"Y\" * 125001 + \"\\n\"); print(\"Z\" * 125001 + \"\\n\");").
-		Timeout(5000 * time.Millisecond).
-		Run()
-	if err != nil {
-		t.Errorf("%v", err)
-	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != 0 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
-	if res1.StdErr != "" {
-		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
-	}
-	if len(res1.StdOut) != 375009 {
-		t.Errorf("len(res1.StdOut) == '%v'", len(res1.StdOut))
-	}
-
-}
-
-func TestFailOnTimeout(t *testing.T) {
-
-	_, err := Runner("sleep").Arg("2").Timeout(200 * time.Millisecond).FailOnTimeout().Run()
-	if !errors.Is(err, ErrTimeout) {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestFailOnStderr(t *testing.T) {
-
-	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").FailOnStderr().Run()
-	if err == nil {
-		t.Errorf("no err")
-	}
-	if res1.CommandTimedOut {
-		t.Errorf("Timeout")
-	}
-	if res1.ExitCode != -1 {
-		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
-	}
-	if res1.StdErr != "error" {
-		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
-	}
-	if res1.StdOut != "" {
-		t.Errorf("res1.StdOut == '%v'", res1.StdOut)
-	}
-	if res1.StdCombined != "error\n" {
-		t.Errorf("res1.StdCombined == '%v'", res1.StdCombined)
-	}
-
-}
-
-func TestFailOnExitcode(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200 * time.Millisecond).FailOnExitCode().Run()
-	if !errors.Is(err, ErrExitCode) {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestEnsureExitcode1(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200 * time.Millisecond).EnsureExitcode(1).Run()
-	if err != nil {
-		t.Errorf("wrong err := %v", err)
-	}
-
-}
-
-func TestEnsureExitcode2(t *testing.T) {
-
-	_, err := Runner("false").Timeout(200*time.Millisecond).EnsureExitcode(0, 2, 3).Run()
-	if err != ErrExitCode {
-		t.Errorf("wrong err := %v", err)
-	}
-
 }

cmdext/pipereader.go

@@ -8,7 +8,6 @@ import (
 )
 
 type pipeReader struct {
-	lineBufferSize *int
 	stdout io.ReadCloser
 	stderr io.ReadCloser
 }
@@ -32,8 +31,9 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	stdout := ""
 	go func() {
 		buf := make([]byte, 128)
-		for {
-			n, err := pr.stdout.Read(buf)
+		for true {
+			n, out := pr.stdout.Read(buf)
+
 			if n > 0 {
 				txt := string(buf[:n])
 				stdout += txt
@@ -42,11 +42,11 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 					lstr.ReadRawStdout(buf[:n])
 				}
 			}
-			if err == io.EOF {
+			if out == io.EOF {
 				break
 			}
-			if err != nil {
-				errch <- err
+			if out != nil {
+				errch <- out
 				break
 			}
 		}
@@ -61,7 +61,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	stderr := ""
 	go func() {
 		buf := make([]byte, 128)
-		for {
+		for true {
 			n, err := pr.stderr.Read(buf)
 
 			if n > 0 {
@@ -91,9 +91,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	wg.Add(1)
 	go func() {
 		scanner := bufio.NewScanner(stdoutBufferReader)
-		if pr.lineBufferSize != nil {
-			scanner.Buffer([]byte{}, *pr.lineBufferSize)
-		}
 		for scanner.Scan() {
 			txt := scanner.Text()
 			for _, lstr := range listener {
@@ -101,9 +98,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			}
 			combch <- combevt{txt, false}
 		}
-		if err := scanner.Err(); err != nil {
-			errch <- err
-		}
 		combch <- combevt{"", true}
 		wg.Done()
 	}()
@@ -113,9 +107,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	wg.Add(1)
 	go func() {
 		scanner := bufio.NewScanner(stderrBufferReader)
-		if pr.lineBufferSize != nil {
-			scanner.Buffer([]byte{}, *pr.lineBufferSize)
-		}
 		for scanner.Scan() {
 			txt := scanner.Text()
 			for _, lstr := range listener {
@@ -123,9 +114,6 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			}
 			combch <- combevt{txt, false}
 		}
-		if err := scanner.Err(); err != nil {
-			errch <- err
-		}
 		combch <- combevt{"", true}
 		wg.Done()
 	}()

confext/confParser.go

@@ -8,7 +8,6 @@ import (
 	"os"
 	"reflect"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -23,10 +22,10 @@ import (
 //
 // sub-structs are recursively parsed (if they have an env tag) and the env-variable keys are delimited by the delim parameter
 // sub-structs with `env:""` are also parsed, but the delimited is skipped (they are handled as if they were one level higher)
-func ApplyEnvOverrides[T any](prefix string, c *T, delim string) error {
+func ApplyEnvOverrides[T any](c *T, delim string) error {
 	rval := reflect.ValueOf(c).Elem()
 
-	return processEnvOverrides(rval, delim, prefix)
+	return processEnvOverrides(rval, delim, "")
 }
 
 func processEnvOverrides(rval reflect.Value, delim string, prefix string) error {
@@ -41,13 +40,13 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			continue
 		}
 
+		if rvfield.Kind() == reflect.Struct {
+
 			envkey, found := rsfield.Tag.Lookup("env")
 			if !found || envkey == "-" {
 				continue
 			}
 
-		if rvfield.Kind() == reflect.Struct && rvfield.Type() != reflect.TypeOf(time.UnixMilli(0)) {
-
 			subPrefix := prefix
 			if envkey != "" {
 				subPrefix = subPrefix + envkey + delim
@@ -57,7 +56,10 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			if err != nil {
 				return err
 			}
+		}
 
+		envkey := rsfield.Tag.Get("env")
+		if envkey == "" || envkey == "-" {
 			continue
 		}
 
@@ -68,128 +70,103 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			continue
 		}
 
-		if rvfield.Type().Kind() == reflect.Pointer {
+		if rvfield.Type() == reflect.TypeOf("") {
 
-			newval, err := parseEnvToValue(envval, fullEnvKey, rvfield.Type().Elem())
-			if err != nil {
-				return err
-			}
-
-			// converts reflect.Value to pointer
-			ptrval := reflect.New(rvfield.Type().Elem())
-			ptrval.Elem().Set(newval)
-
-			rvfield.Set(ptrval)
+			rvfield.Set(reflect.ValueOf(envval))
 
 			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
 
+		} else if rvfield.Type() == reflect.TypeOf(int(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int64(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 64)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int64 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int64(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int32(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 32)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int32(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int8(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int8(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(time.Duration(0)) {
+
+			dur, err := timeext.ParseDurationShortString(envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to duration (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(dur))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, dur.String())
+
+		} else if rvfield.Type() == reflect.TypeOf(time.UnixMilli(0)) {
+
+			tim, err := time.Parse(time.RFC3339Nano, envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to time.time (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(tim))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, tim.String())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf(int(0))) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,int> (value := '%s')", rvfield.Type().Name(), fullEnvKey, envval))
+			}
+
+			envcvl := reflect.ValueOf(envint).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", fullEnvKey, envcvl.Interface())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf("")) {
+
+			envcvl := reflect.ValueOf(envval).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", fullEnvKey, envcvl.Interface())
+
 		} else {
-
-			newval, err := parseEnvToValue(envval, fullEnvKey, rvfield.Type())
-			if err != nil {
-				return err
+			return errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvfield.Kind().String(), rvfield.Type().String()))
 		}
-
-			rvfield.Set(newval)
-			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
-
-		}
-
 	}
 
 	return nil
 }
-
-func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (reflect.Value, error) {
-	if rvtype == reflect.TypeOf("") {
-
-		return reflect.ValueOf(envval), nil
-
-	} else if rvtype == reflect.TypeOf(int(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int64(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 64)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int64 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int64(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int32(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 32)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int32(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(int8(0)) {
-
-		envint, err := strconv.ParseInt(envval, 10, 8)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(int8(envint)), nil
-
-	} else if rvtype == reflect.TypeOf(time.Duration(0)) {
-
-		dur, err := timeext.ParseDurationShortString(envval)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to duration (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(dur), nil
-
-	} else if rvtype == reflect.TypeOf(time.UnixMilli(0)) {
-
-		tim, err := time.Parse(time.RFC3339Nano, envval)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to time.time (value := '%s')", fullEnvKey, envval))
-		}
-
-		return reflect.ValueOf(tim), nil
-
-	} else if rvtype.ConvertibleTo(reflect.TypeOf(int(0))) {
-
-		envint, err := strconv.ParseInt(envval, 10, 8)
-		if err != nil {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,int> (value := '%s')", rvtype.Name(), fullEnvKey, envval))
-		}
-
-		envcvl := reflect.ValueOf(envint).Convert(rvtype)
-
-		return envcvl, nil
-
-	} else if rvtype.ConvertibleTo(reflect.TypeOf(false)) {
-
-		if strings.TrimSpace(strings.ToLower(envval)) == "true" {
-			return reflect.ValueOf(true).Convert(rvtype), nil
-		} else if strings.TrimSpace(strings.ToLower(envval)) == "false" {
-			return reflect.ValueOf(false).Convert(rvtype), nil
-		} else if strings.TrimSpace(strings.ToLower(envval)) == "1" {
-			return reflect.ValueOf(true).Convert(rvtype), nil
-		} else if strings.TrimSpace(strings.ToLower(envval)) == "0" {
-			return reflect.ValueOf(false).Convert(rvtype), nil
-		} else {
-			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,bool> (value := '%s')", rvtype.Name(), fullEnvKey, envval))
-		}
-
-	} else if rvtype.ConvertibleTo(reflect.TypeOf("")) {
-
-		envcvl := reflect.ValueOf(envval).Convert(rvtype)
-		return envcvl, nil
-
-	} else {
-		return reflect.Value{}, errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvtype.Kind().String(), rvtype.String()))
-	}
-}

confext/confParser_test.go

@@ -2,7 +2,6 @@ package confext
 
 import (
 	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
 )
@@ -42,13 +41,13 @@ func TestApplyEnvOverridesNoop(t *testing.T) {
 
 	output := input
 
-	err := ApplyEnvOverrides("", &output, ".")
+	err := ApplyEnvOverrides(&output, ".")
 	if err != nil {
 		t.Errorf("%v", err)
 		t.FailNow()
 	}
 
-	tst.AssertEqual(t, input, output)
+	assertEqual(t, input, output)
 }
 
 func TestApplyEnvOverridesSimple(t *testing.T) {
@@ -68,7 +67,6 @@ func TestApplyEnvOverridesSimple(t *testing.T) {
 		V7 aliasstring   `env:"TEST_V7"`
 		V8 time.Duration `env:"TEST_V8"`
 		V9 time.Time     `env:"TEST_V9"`
-		VA bool          `env:"TEST_VA"`
 	}
 
 	data := testdata{
@@ -83,7 +81,6 @@ func TestApplyEnvOverridesSimple(t *testing.T) {
 		V7: "7",
 		V8: 9,
 		V9: time.Unix(1671102873, 0),
-		VA: false,
 	}
 
 	t.Setenv("TEST_V1", "846")
@@ -95,24 +92,22 @@ func TestApplyEnvOverridesSimple(t *testing.T) {
 	t.Setenv("TEST_V7", "AAAAAA")
 	t.Setenv("TEST_V8", "1min4s")
 	t.Setenv("TEST_V9", "2009-11-10T23:00:00Z")
-	t.Setenv("TEST_VA", "true")
 
-	err := ApplyEnvOverrides("", &data, ".")
+	err := ApplyEnvOverrides(&data, ".")
 	if err != nil {
 		t.Errorf("%v", err)
 		t.FailNow()
 	}
 
-	tst.AssertEqual(t, data.V1, 846)
-	tst.AssertEqual(t, data.V2, "hello_world")
-	tst.AssertEqual(t, data.V3, 6)
-	tst.AssertEqual(t, data.V4, 333)
-	tst.AssertEqual(t, data.V5, -937)
-	tst.AssertEqual(t, data.V6, 70)
-	tst.AssertEqual(t, data.V7, "AAAAAA")
-	tst.AssertEqual(t, data.V8, time.Second*64)
-	tst.AssertEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
-	tst.AssertEqual(t, data.VA, true)
+	assertEqual(t, data.V1, 846)
+	assertEqual(t, data.V2, "hello_world")
+	assertEqual(t, data.V3, 6)
+	assertEqual(t, data.V4, 333)
+	assertEqual(t, data.V5, -937)
+	assertEqual(t, data.V6, 70)
+	assertEqual(t, data.V7, "AAAAAA")
+	assertEqual(t, data.V8, time.Second*64)
+	assertEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
 }
 
 func TestApplyEnvOverridesRecursive(t *testing.T) {
@@ -187,83 +182,35 @@ func TestApplyEnvOverridesRecursive(t *testing.T) {
 	t.Setenv("SUB_V3", "33min")
 	t.Setenv("SUB_V4", "2044-01-01T00:00:00Z")
 
-	err := ApplyEnvOverrides("", &data, "_")
+	err := ApplyEnvOverrides(&data, "_")
 	if err != nil {
 		t.Errorf("%v", err)
 		t.FailNow()
 	}
 
-	tst.AssertEqual(t, data.V1, 999)
-	tst.AssertEqual(t, data.VX, "2")
-	tst.AssertEqual(t, data.V5, "no")
-	tst.AssertEqual(t, data.Sub1.V1, 3)
-	tst.AssertEqual(t, data.Sub1.VX, "4")
-	tst.AssertEqual(t, data.Sub1.V2, "5")
-	tst.AssertEqual(t, data.Sub1.V8, time.Second*6)
-	tst.AssertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC())
-	tst.AssertEqual(t, data.Sub2.V1, 846)
-	tst.AssertEqual(t, data.Sub2.VX, "9")
-	tst.AssertEqual(t, data.Sub2.V2, "222_hello_world")
-	tst.AssertEqual(t, data.Sub2.V8, time.Second*64)
-	tst.AssertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC())
-	tst.AssertEqual(t, data.Sub3.V1, 33846)
-	tst.AssertEqual(t, data.Sub3.VX, "14")
-	tst.AssertEqual(t, data.Sub3.V2, "33_hello_world")
-	tst.AssertEqual(t, data.Sub3.V8, time.Second*1984)
-	tst.AssertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC())
-	tst.AssertEqual(t, data.Sub4.V1, 11)
-	tst.AssertEqual(t, data.Sub4.VX, "19")
-	tst.AssertEqual(t, data.Sub4.V2, "22")
-	tst.AssertEqual(t, data.Sub4.V8, time.Second*1980)
-	tst.AssertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC())
-}
-
-func TestApplyEnvOverridesPointer(t *testing.T) {
-
-	type aliasint int
-	type aliasstring string
-
-	type testdata struct {
-		V1 *int           `env:"TEST_V1"`
-		VX *string        ``
-		V2 *string        `env:"TEST_V2"`
-		V3 *int8          `env:"TEST_V3"`
-		V4 *int32         `env:"TEST_V4"`
-		V5 *int64         `env:"TEST_V5"`
-		V6 *aliasint      `env:"TEST_V6"`
-		VY *aliasint      ``
-		V7 *aliasstring   `env:"TEST_V7"`
-		V8 *time.Duration `env:"TEST_V8"`
-		V9 *time.Time     `env:"TEST_V9"`
-	}
-
-	data := testdata{}
-
-	t.Setenv("TEST_V1", "846")
-	t.Setenv("TEST_V2", "hello_world")
-	t.Setenv("TEST_V3", "6")
-	t.Setenv("TEST_V4", "333")
-	t.Setenv("TEST_V5", "-937")
-	t.Setenv("TEST_V6", "070")
-	t.Setenv("TEST_V7", "AAAAAA")
-	t.Setenv("TEST_V8", "1min4s")
-	t.Setenv("TEST_V9", "2009-11-10T23:00:00Z")
-
-	err := ApplyEnvOverrides("", &data, ".")
-	if err != nil {
-		t.Errorf("%v", err)
-		t.FailNow()
-	}
-
-	tst.AssertDeRefEqual(t, data.V1, 846)
-	tst.AssertDeRefEqual(t, data.V2, "hello_world")
-	tst.AssertDeRefEqual(t, data.V3, 6)
-	tst.AssertDeRefEqual(t, data.V4, 333)
-	tst.AssertDeRefEqual(t, data.V5, -937)
-	tst.AssertDeRefEqual(t, data.V6, 70)
-	tst.AssertDeRefEqual(t, data.V7, "AAAAAA")
-	tst.AssertDeRefEqual(t, data.V8, time.Second*64)
-	tst.AssertDeRefEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
+	assertEqual(t, data.V1, 999)
+	assertEqual(t, data.VX, "2")
+	assertEqual(t, data.V5, "no")
+	assertEqual(t, data.Sub1.V1, 3)
+	assertEqual(t, data.Sub1.VX, "4")
+	assertEqual(t, data.Sub1.V2, "5")
+	assertEqual(t, data.Sub1.V8, time.Second*6)
+	assertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC())
+	assertEqual(t, data.Sub2.V1, 846)
+	assertEqual(t, data.Sub2.VX, "9")
+	assertEqual(t, data.Sub2.V2, "222_hello_world")
+	assertEqual(t, data.Sub2.V8, time.Second*64)
+	assertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC())
+	assertEqual(t, data.Sub3.V1, 33846)
+	assertEqual(t, data.Sub3.VX, "14")
+	assertEqual(t, data.Sub3.V2, "33_hello_world")
+	assertEqual(t, data.Sub3.V8, time.Second*1984)
+	assertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC())
+	assertEqual(t, data.Sub4.V1, 11)
+	assertEqual(t, data.Sub4.VX, "19")
+	assertEqual(t, data.Sub4.V2, "22")
+	assertEqual(t, data.Sub4.V8, time.Second*1980)
+	assertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC())
 }
 
 func assertEqual[T comparable](t *testing.T, actual T, expected T) {
@@ -271,12 +218,3 @@ func assertEqual[T comparable](t *testing.T, actual T, expected T) {
 		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
 	}
 }
-
-func assertPtrEqual[T comparable](t *testing.T, actual *T, expected T) {
-	if actual == nil {
-		t.Errorf("values differ: Actual: NIL, Expected: '%v'", expected)
-	}
-	if *actual != expected {
-		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
-	}
-}

cryptext/aes_test.go

@@ -2,7 +2,6 @@ package cryptext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 
@@ -24,13 +23,13 @@ func TestEncryptAESSimple(t *testing.T) {
 		panic(err)
 	}
 
-	tst.AssertEqual(t, string(str1), string(str3))
+	assertEqual(t, string(str1), string(str3))
 
 	str4, err := EncryptAESSimple(pw, str3, 512)
 	if err != nil {
 		panic(err)
 	}
 
-	tst.AssertNotEqual(t, string(str2), string(str4))
+	assertNotEqual(t, string(str2), string(str4))
 
 }

cryptext/hash_test.go

@@ -1,20 +1,31 @@
 package cryptext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 
 func TestStrSha256(t *testing.T) {
-	tst.AssertEqual(t, StrSha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
-	tst.AssertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9")
-	tst.AssertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b")
-	tst.AssertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e")
+	assertEqual(t, StrSha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+	assertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9")
+	assertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b")
+	assertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e")
 }
 
 func TestBytesSha256(t *testing.T) {
-	tst.AssertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
-	tst.AssertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d")
-	tst.AssertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71")
-	tst.AssertEqual(t, BytesSha256([]byte{0, 1, 2, 4, 8, 16, 32, 64, 128, 255}), "55016a318ba538e00123c736b2a8b6db368d00e7e25727547655b653e5853603")
+	assertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+	assertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d")
+	assertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71")
+	assertEqual(t, BytesSha256([]byte{0, 1, 2, 4, 8, 16, 32, 64, 128, 255}), "55016a318ba538e00123c736b2a8b6db368d00e7e25727547655b653e5853603")
+}
+
+func assertEqual(t *testing.T, actual string, expected string) {
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
+}
+
+func assertNotEqual(t *testing.T, actual string, expected string) {
+	if actual == expected {
+		t.Errorf("values do not differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
 }

cryptext/passHash.go

@@ -3,7 +3,6 @@ package cryptext
 import (
 	"crypto/rand"
 	"crypto/sha256"
-	"crypto/sha512"
 	"encoding/base64"
 	"encoding/hex"
 	"errors"
@@ -15,15 +14,14 @@ import (
 	"strings"
 )
 
-const LatestPassHashVersion = 5
+const LatestPassHashVersion = 4
 
 // PassHash
-// - [v0]: plaintext password ( `0|...` )                  // simple, used to write PW's directly in DB
-// - [v1]: sha256(plaintext)                               // simple hashing
-// - [v2]: seed | sha256<seed>(plaintext)                  // add seed
-// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]    // add TOTP support
-// - [v4]: bcrypt(plaintext) | [hex(totp)]                 // use proper bcrypt
-// - [v5]: bcrypt(sha512(plaintext)) | [hex(totp)]         // hash pw before bcrypt (otherwise max pw-len = 72)
+// - [v0]: plaintext password ( `0|...` )
+// - [v1]: sha256(plaintext)
+// - [v2]: seed | sha256<seed>(plaintext)
+// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]
+// - [v4]: bcrypt(plaintext) | [hex(totp)]
 type PassHash string
 
 func (ph PassHash) Valid() bool {
@@ -66,6 +64,7 @@ func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bo
 		return int(version), nil, payload, false, nil, true
 	}
 
+	//
 	if version == 2 {
 		if len(split) != 3 {
 			return -1, nil, nil, false, nil, false
@@ -110,21 +109,7 @@ func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bo
 		totp := false
 		totpsecret := make([]byte, 0)
 		if split[2] != "0" {
-			totpsecret, err = hex.DecodeString(split[2])
-			totp = true
-		}
-		return int(version), nil, payload, totp, totpsecret, true
-	}
-
-	if version == 5 {
-		if len(split) != 3 {
-			return -1, nil, nil, false, nil, false
-		}
-		payload := []byte(split[1])
-		totp := false
-		totpsecret := make([]byte, 0)
-		if split[2] != "0" {
-			totpsecret, err = hex.DecodeString(split[2])
+			totpsecret, err = hex.DecodeString(split[3])
 			totp = true
 		}
 		return int(version), nil, payload, totp, totpsecret, true
@@ -171,14 +156,6 @@ func (ph PassHash) Verify(plainpass string, totp *string) bool {
 		}
 	}
 
-	if version == 5 {
-		if !hastotp {
-			return bcrypt.CompareHashAndPassword(payload, hash512(plainpass)) == nil
-		} else {
-			return bcrypt.CompareHashAndPassword(payload, hash512(plainpass)) == nil && totpext.Validate(totpsecret, *totp)
-		}
-	}
-
 	return false
 }
 
@@ -232,12 +209,6 @@ func (ph PassHash) ClearTOTP() (PassHash, error) {
 		return PassHash(strings.Join(split, "|")), nil
 	}
 
-	if version == 5 {
-		split := strings.Split(string(ph), "|")
-		split[2] = "0"
-		return PassHash(strings.Join(split, "|")), nil
-	}
-
 	return "", errors.New("unknown version")
 }
 
@@ -271,12 +242,6 @@ func (ph PassHash) WithTOTP(totpSecret []byte) (PassHash, error) {
 		return PassHash(strings.Join(split, "|")), nil
 	}
 
-	if version == 5 {
-		split := strings.Split(string(ph), "|")
-		split[2] = hex.EncodeToString(totpSecret)
-		return PassHash(strings.Join(split, "|")), nil
-	}
-
 	return "", errors.New("unknown version")
 }
 
@@ -306,10 +271,6 @@ func (ph PassHash) Change(newPlainPass string) (PassHash, error) {
 		return HashPasswordV4(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
 	}
 
-	if version == 5 {
-		return HashPasswordV5(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
-	}
-
 	return "", errors.New("unknown version")
 }
 
@@ -318,24 +279,7 @@ func (ph PassHash) String() string {
 }
 
 func HashPassword(plainpass string, totpSecret []byte) (PassHash, error) {
-	return HashPasswordV5(plainpass, totpSecret)
-}
-
-func HashPasswordV5(plainpass string, totpSecret []byte) (PassHash, error) {
-	var strtotp string
-
-	if totpSecret == nil {
-		strtotp = "0"
-	} else {
-		strtotp = hex.EncodeToString(totpSecret)
-	}
-
-	payload, err := bcrypt.GenerateFromPassword(hash512(plainpass), bcrypt.MinCost)
-	if err != nil {
-		return "", err
-	}
-
-	return PassHash(fmt.Sprintf("5|%s|%s", string(payload), strtotp)), nil
+	return HashPasswordV4(plainpass, totpSecret)
 }
 
 func HashPasswordV4(plainpass string, totpSecret []byte) (PassHash, error) {
@@ -396,13 +340,6 @@ func HashPasswordV0(plainpass string) (PassHash, error) {
 	return PassHash(fmt.Sprintf("0|%s", plainpass)), nil
 }
 
-func hash512(s string) []byte {
-	h := sha512.New()
-	h.Write([]byte(s))
-	bs := h.Sum(nil)
-	return bs
-}
-
 func hash256(s string) []byte {
 	h := sha256.New()
 	h.Write([]byte(s))

cryptext/passHash_test.go

@@ -1,210 +0,0 @@
-package cryptext
-
-import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"testing"
-)
-
-func TestPassHash1(t *testing.T) {
-	ph, err := HashPassword("test123", nil)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-}
-
-func TestPassHashTOTP(t *testing.T) {
-	sec, err := totpext.GenerateSecret()
-	tst.AssertNoErr(t, err)
-
-	ph, err := HashPassword("test123", sec)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertTrue(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertFalse(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-}
-
-func TestPassHashUpgrade_V0(t *testing.T) {
-	ph, err := HashPasswordV0("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-}
-
-func TestPassHashUpgrade_V1(t *testing.T) {
-	ph, err := HashPasswordV1("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-}
-
-func TestPassHashUpgrade_V2(t *testing.T) {
-	ph, err := HashPasswordV2("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-}
-
-func TestPassHashUpgrade_V3(t *testing.T) {
-	ph, err := HashPasswordV3("test123", nil)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-}
-
-func TestPassHashUpgrade_V3_TOTP(t *testing.T) {
-	sec, err := totpext.GenerateSecret()
-	tst.AssertNoErr(t, err)
-
-	ph, err := HashPasswordV3("test123", sec)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertTrue(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertFalse(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertTrue(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertFalse(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-}
-
-func TestPassHashUpgrade_V4(t *testing.T) {
-	ph, err := HashPasswordV4("test123", nil)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertFalse(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertTrue(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-}
-
-func TestPassHashUpgrade_V4_TOTP(t *testing.T) {
-	sec, err := totpext.GenerateSecret()
-	tst.AssertNoErr(t, err)
-
-	ph, err := HashPasswordV4("test123", sec)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertTrue(t, ph.HasTOTP())
-	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertFalse(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-
-	ph, err = ph.Upgrade("test123")
-	tst.AssertNoErr(t, err)
-
-	tst.AssertTrue(t, ph.Valid())
-	tst.AssertTrue(t, ph.HasTOTP())
-	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
-
-	tst.AssertFalse(t, ph.Verify("test123", nil))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
-	tst.AssertFalse(t, ph.Verify("test124", nil))
-}

cryptext/pronouncablePassword.go

@@ -1,263 +0,0 @@
-package cryptext
-
-import (
-	"crypto/rand"
-	"io"
-	"math/big"
-	mathrand "math/rand"
-	"strings"
-)
-
-const (
-	ppStartChar            = "BCDFGHJKLMNPQRSTVWXZ"
-	ppEndChar              = "ABDEFIKMNORSTUXYZ"
-	ppVowel                = "AEIOUY"
-	ppConsonant            = "BCDFGHJKLMNPQRSTVWXZ"
-	ppSegmentLenMin        = 3
-	ppSegmentLenMax        = 7
-	ppMaxRepeatedVowel     = 2
-	ppMaxRepeatedConsonant = 2
-)
-
-var ppContinuation = map[uint8]string{
-	'A': "BCDFGHJKLMNPRSTVWXYZ",
-	'B': "ADFIKLMNORSTUY",
-	'C': "AEIKOUY",
-	'D': "AEILORSUYZ",
-	'E': "BCDFGHJKLMNPRSTVWXYZ",
-	'F': "ADEGIKLOPRTUY",
-	'G': "ABDEFHILMNORSTUY",
-	'H': "AEIOUY",
-	'I': "BCDFGHJKLMNPRSTVWXZ",
-	'J': "AEIOUY",
-	'K': "ADEFHILMNORSTUY",
-	'L': "ADEFGIJKMNOPSTUVWYZ",
-	'M': "ABEFIKOPSTUY",
-	'N': "ABEFIKOPSTUY",
-	'O': "BCDFGHJKLMNPRSTVWXYZ",
-	'P': "AEFIJLORSTUY",
-	'Q': "AEIOUY",
-	'R': "ADEFGHIJKLMNOPSTUVYZ",
-	'S': "ACDEIKLOPTUYZ",
-	'T': "AEHIJOPRSUWY",
-	'U': "BCDFGHJKLMNPRSTVWXZ",
-	'V': "AEIOUY",
-	'W': "AEIOUY",
-	'X': "AEIOUY",
-	'Y': "ABCDFGHKLMNPRSTVXZ",
-	'Z': "AEILOTUY",
-}
-
-var ppLog2Map = map[int]float64{
-	1:  0.00000000,
-	2:  1.00000000,
-	3:  1.58496250,
-	4:  2.00000000,
-	5:  2.32192809,
-	6:  2.58496250,
-	7:  2.80735492,
-	8:  3.00000000,
-	9:  3.16992500,
-	10: 3.32192809,
-	11: 3.45943162,
-	12: 3.58496250,
-	13: 3.70043972,
-	14: 3.80735492,
-	15: 3.90689060,
-	16: 4.00000000,
-	17: 4.08746284,
-	18: 4.16992500,
-	19: 4.24792751,
-	20: 4.32192809,
-	21: 4.39231742,
-	22: 4.45943162,
-	23: 4.52356196,
-	24: 4.58496250,
-	25: 4.64385619,
-	26: 4.70043972,
-	27: 4.75488750,
-	28: 4.80735492,
-	29: 4.85798100,
-	30: 4.90689060,
-	31: 4.95419631,
-	32: 5.00000000,
-}
-
-var (
-	ppVowelMap     = ppMakeSet(ppVowel)
-	ppConsonantMap = ppMakeSet(ppConsonant)
-	ppEndCharMap   = ppMakeSet(ppEndChar)
-)
-
-func ppMakeSet(v string) map[uint8]bool {
-	mp := make(map[uint8]bool, len(v))
-	for _, chr := range v {
-		mp[uint8(chr)] = true
-	}
-	return mp
-}
-
-func ppRandInt(rng io.Reader, max int) int {
-	v, err := rand.Int(rng, big.NewInt(int64(max)))
-	if err != nil {
-		panic(err)
-	}
-	return int(v.Int64())
-}
-
-func ppRand(rng io.Reader, chars string, entropy *float64) uint8 {
-	chr := chars[ppRandInt(rng, len(chars))]
-
-	*entropy = *entropy + ppLog2Map[len(chars)]
-
-	return chr
-}
-
-func ppCharType(chr uint8) (bool, bool) {
-	_, ok1 := ppVowelMap[chr]
-	_, ok2 := ppConsonantMap[chr]
-
-	return ok1, ok2
-}
-
-func ppCharsetRemove(cs string, set map[uint8]bool, allowEmpty bool) string {
-	result := ""
-	for _, chr := range cs {
-		if _, ok := set[uint8(chr)]; !ok {
-			result += string(chr)
-		}
-	}
-	if result == "" && !allowEmpty {
-		return cs
-	}
-	return result
-}
-
-func ppCharsetFilter(cs string, set map[uint8]bool, allowEmpty bool) string {
-	result := ""
-	for _, chr := range cs {
-		if _, ok := set[uint8(chr)]; ok {
-			result += string(chr)
-		}
-	}
-	if result == "" && !allowEmpty {
-		return cs
-	}
-	return result
-}
-
-func PronouncablePasswordExt(rng io.Reader, pwlen int) (string, float64) {
-
-	// kinda pseudo markov-chain - with a few extra rules and no weights...
-
-	if pwlen <= 0 {
-		return "", 0
-	}
-
-	vowelCount := 0
-	consoCount := 0
-	entropy := float64(0)
-
-	startChar := ppRand(rng, ppStartChar, &entropy)
-
-	result := string(startChar)
-	currentChar := startChar
-
-	isVowel, isConsonant := ppCharType(currentChar)
-	if isVowel {
-		vowelCount = 1
-	}
-	if isConsonant {
-		consoCount = ppMaxRepeatedConsonant
-	}
-
-	segmentLen := 1
-
-	segmentLenTarget := ppSegmentLenMin + ppRandInt(rng, ppSegmentLenMax-ppSegmentLenMin)
-
-	for len(result) < pwlen {
-
-		charset := ppContinuation[currentChar]
-		if vowelCount >= ppMaxRepeatedVowel {
-			charset = ppCharsetRemove(charset, ppVowelMap, false)
-		}
-		if consoCount >= ppMaxRepeatedConsonant {
-			charset = ppCharsetRemove(charset, ppConsonantMap, false)
-		}
-
-		lastOfSegment := false
-		newSegment := false
-
-		if len(result)+1 == pwlen {
-			// last of result
-			charset = ppCharsetFilter(charset, ppEndCharMap, false)
-		} else if segmentLen+1 == segmentLenTarget {
-			// last of segment
-			charsetNew := ppCharsetFilter(charset, ppEndCharMap, true)
-			if charsetNew != "" {
-				charset = charsetNew
-				lastOfSegment = true
-			}
-		} else if segmentLen >= segmentLenTarget {
-			// (perhaps) start of new segment
-			if _, ok := ppEndCharMap[currentChar]; ok {
-				charset = ppStartChar
-				newSegment = true
-			} else {
-				// continue segment for one more char to (hopefully) find an end-char
-				charsetNew := ppCharsetFilter(charset, ppEndCharMap, true)
-				if charsetNew != "" {
-					charset = charsetNew
-					lastOfSegment = true
-				}
-			}
-		} else {
-			// normal continuation
-		}
-
-		newChar := ppRand(rng, charset, &entropy)
-		if lastOfSegment {
-			currentChar = newChar
-			segmentLen++
-			result += strings.ToLower(string(newChar))
-		} else if newSegment {
-			currentChar = newChar
-			segmentLen = 1
-			result += strings.ToUpper(string(newChar))
-			segmentLenTarget = ppSegmentLenMin + ppRandInt(rng, ppSegmentLenMax-ppSegmentLenMin)
-			vowelCount = 0
-			consoCount = 0
-		} else {
-			currentChar = newChar
-			segmentLen++
-			result += strings.ToLower(string(newChar))
-		}
-
-		isVowel, isConsonant := ppCharType(currentChar)
-		if isVowel {
-			vowelCount++
-			consoCount = 0
-		}
-		if isConsonant {
-			vowelCount = 0
-			if newSegment {
-				consoCount = ppMaxRepeatedConsonant
-			} else {
-				consoCount++
-			}
-		}
-	}
-
-	return result, entropy
-}
-
-func PronouncablePassword(len int) string {
-	v, _ := PronouncablePasswordExt(rand.Reader, len)
-	return v
-}
-
-func PronouncablePasswordSeeded(seed int64, len int) string {
-
-	v, _ := PronouncablePasswordExt(mathrand.New(mathrand.NewSource(seed)), len)
-	return v
-}

cryptext/pronouncablePassword_test.go

@@ -1,35 +0,0 @@
-package cryptext
-
-import (
-	"fmt"
-	"math/rand"
-	"testing"
-)
-
-func TestPronouncablePasswordExt(t *testing.T) {
-	for i := 0; i < 20; i++ {
-		pw, entropy := PronouncablePasswordExt(rand.New(rand.NewSource(int64(i))), 16)
-		fmt.Printf("[%.2f] => %s\n", entropy, pw)
-	}
-}
-
-func TestPronouncablePasswordSeeded(t *testing.T) {
-	for i := 0; i < 20; i++ {
-		pw := PronouncablePasswordSeeded(int64(i), 8)
-		fmt.Printf("%s\n", pw)
-	}
-}
-
-func TestPronouncablePassword(t *testing.T) {
-	for i := 0; i < 20; i++ {
-		pw := PronouncablePassword(i + 1)
-		fmt.Printf("%s\n", pw)
-	}
-}
-
-func TestPronouncablePasswordWrongLen(t *testing.T) {
-	PronouncablePassword(0)
-	PronouncablePassword(-1)
-	PronouncablePassword(-2)
-	PronouncablePassword(-3)
-}

ctxext/getter.go

@@ -1,27 +0,0 @@
-package ctxext
-
-import "context"
-
-func Value[T any](ctx context.Context, key any) (T, bool) {
-	v := ctx.Value(key)
-	if v == nil {
-		return *new(T), false
-	}
-	if tv, ok := v.(T); !ok {
-		return *new(T), false
-	} else {
-		return tv, true
-	}
-}
-
-func ValueOrDefault[T any](ctx context.Context, key any, def T) T {
-	v := ctx.Value(key)
-	if v == nil {
-		return def
-	}
-	if tv, ok := v.(T); !ok {
-		return def
-	} else {
-		return tv
-	}
-}

cursortoken/direction.go

@@ -1,18 +0,0 @@
-package cursortoken
-
-type SortDirection string //@enum:type
-
-const (
-	SortASC  SortDirection = "ASC"
-	SortDESC SortDirection = "DESC"
-)
-
-func (sd SortDirection) ToMongo() int {
-	if sd == SortASC {
-		return 1
-	} else if sd == SortDESC {
-		return -1
-	} else {
-		return 0
-	}
-}

cursortoken/filter.go

@@ -1,15 +0,0 @@
-package cursortoken
-
-import (
-	"context"
-	"go.mongodb.org/mongo-driver/mongo"
-)
-
-type RawFilter interface {
-	FilterQuery(ctx context.Context) mongo.Pipeline
-}
-
-type Filter interface {
-	FilterQuery(ctx context.Context) mongo.Pipeline
-	Pagination(ctx context.Context) (string, SortDirection, string, SortDirection)
-}

cursortoken/token.go

@@ -1,95 +0,0 @@
-package cursortoken
-
-import (
-	"encoding/base32"
-	"encoding/json"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type CursorToken interface {
-	Token() string
-	IsStart() bool
-	IsEnd() bool
-}
-
-type Mode string
-
-const (
-	CTMStart  Mode = "START"
-	CTMNormal Mode = "NORMAL"
-	CTMEnd    Mode = "END"
-)
-
-type Extra struct {
-	Timestamp *time.Time
-	Id        *string
-	Page      *int
-	PageSize  *int
-}
-
-func Decode(tok string) (CursorToken, error) {
-	if tok == "" {
-		return Start(), nil
-	}
-	if strings.ToLower(tok) == "@start" {
-		return Start(), nil
-	}
-	if strings.ToLower(tok) == "@end" {
-		return End(), nil
-	}
-	if strings.ToLower(tok) == "$end" {
-		return PageEnd(), nil
-	}
-	if strings.HasPrefix(tok, "$") && len(tok) > 1 {
-		n, err := strconv.ParseInt(tok[1:], 10, 64)
-		if err != nil {
-			return nil, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).WithType(exerr.TypeCursorTokenDecode).Build()
-		}
-		return Page(int(n)), nil
-	}
-
-	if strings.HasPrefix(tok, "tok_") {
-
-		body, err := base32.StdEncoding.DecodeString(tok[len("tok_"):])
-		if err != nil {
-			return nil, err
-		}
-
-		var tokenDeserialize cursorTokenKeySortSerialize
-		err = json.Unmarshal(body, &tokenDeserialize)
-		if err != nil {
-			return nil, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).WithType(exerr.TypeCursorTokenDecode).Build()
-		}
-
-		token := CTKeySort{Mode: CTMNormal}
-
-		if tokenDeserialize.ValuePrimary != nil {
-			token.ValuePrimary = *tokenDeserialize.ValuePrimary
-		}
-		if tokenDeserialize.ValueSecondary != nil {
-			token.ValueSecondary = *tokenDeserialize.ValueSecondary
-		}
-		if tokenDeserialize.Direction != nil {
-			token.Direction = *tokenDeserialize.Direction
-		}
-		if tokenDeserialize.DirectionSecondary != nil {
-			token.DirectionSecondary = *tokenDeserialize.DirectionSecondary
-		}
-		if tokenDeserialize.PageSize != nil {
-			token.PageSize = *tokenDeserialize.PageSize
-		}
-
-		token.Extra.Timestamp = tokenDeserialize.ExtraTimestamp
-		token.Extra.Id = tokenDeserialize.ExtraId
-		token.Extra.Page = tokenDeserialize.ExtraPage
-		token.Extra.PageSize = tokenDeserialize.ExtraPageSize
-
-		return token, nil
-
-	} else {
-		return nil, exerr.New(exerr.TypeCursorTokenDecode, "could not decode token, missing/unknown prefix").Str("token", tok).Build()
-	}
-}

cursortoken/tokenKeySort.go

@@ -1,136 +0,0 @@
-package cursortoken
-
-import (
-	"encoding/base32"
-	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"time"
-)
-
-type CTKeySort struct {
-	Mode               Mode
-	ValuePrimary       string
-	ValueSecondary     string
-	Direction          SortDirection
-	DirectionSecondary SortDirection
-	PageSize           int
-	Extra              Extra
-}
-
-type cursorTokenKeySortSerialize struct {
-	ValuePrimary       *string        `json:"v1,omitempty"`
-	ValueSecondary     *string        `json:"v2,omitempty"`
-	Direction          *SortDirection `json:"dir,omitempty"`
-	DirectionSecondary *SortDirection `json:"dir2,omitempty"`
-	PageSize           *int           `json:"size,omitempty"`
-
-	ExtraTimestamp *time.Time `json:"ts,omitempty"`
-	ExtraId        *string    `json:"id,omitempty"`
-	ExtraPage      *int       `json:"pg,omitempty"`
-	ExtraPageSize  *int       `json:"sz,omitempty"`
-}
-
-func NewKeySortToken(valuePrimary string, valueSecondary string, direction SortDirection, directionSecondary SortDirection, pageSize int, extra Extra) CursorToken {
-	return CTKeySort{
-		Mode:               CTMNormal,
-		ValuePrimary:       valuePrimary,
-		ValueSecondary:     valueSecondary,
-		Direction:          direction,
-		DirectionSecondary: directionSecondary,
-		PageSize:           pageSize,
-		Extra:              extra,
-	}
-}
-
-func Start() CursorToken {
-	return CTKeySort{
-		Mode:               CTMStart,
-		ValuePrimary:       "",
-		ValueSecondary:     "",
-		Direction:          "",
-		DirectionSecondary: "",
-		PageSize:           0,
-		Extra:              Extra{},
-	}
-}
-
-func End() CursorToken {
-	return CTKeySort{
-		Mode:               CTMEnd,
-		ValuePrimary:       "",
-		ValueSecondary:     "",
-		Direction:          "",
-		DirectionSecondary: "",
-		PageSize:           0,
-		Extra:              Extra{},
-	}
-}
-
-func (c CTKeySort) Token() string {
-
-	if c.Mode == CTMStart {
-		return "@start"
-	}
-	if c.Mode == CTMEnd {
-		return "@end"
-	}
-
-	// We kinda manually implement omitempty for the CursorToken here
-	// because omitempty does not work for time.Time and otherwise we would always
-	// get weird time values when decoding a token that initially didn't have an Timestamp set
-	// For this usecase we treat Unix=0 as an empty timestamp
-
-	sertok := cursorTokenKeySortSerialize{}
-
-	if c.ValuePrimary != "" {
-		sertok.ValuePrimary = &c.ValuePrimary
-	}
-	if c.ValueSecondary != "" {
-		sertok.ValueSecondary = &c.ValueSecondary
-	}
-	if c.Direction != "" {
-		sertok.Direction = &c.Direction
-	}
-	if c.DirectionSecondary != "" {
-		sertok.DirectionSecondary = &c.DirectionSecondary
-	}
-	if c.PageSize != 0 {
-		sertok.PageSize = &c.PageSize
-	}
-
-	sertok.ExtraTimestamp = c.Extra.Timestamp
-	sertok.ExtraId = c.Extra.Id
-	sertok.ExtraPage = c.Extra.Page
-	sertok.ExtraPageSize = c.Extra.PageSize
-
-	body, err := json.Marshal(sertok)
-	if err != nil {
-		panic(err)
-	}
-
-	return "tok_" + base32.StdEncoding.EncodeToString(body)
-}
-
-func (c CTKeySort) IsEnd() bool {
-	return c.Mode == CTMEnd
-}
-
-func (c CTKeySort) IsStart() bool {
-	return c.Mode == CTMStart
-}
-
-func (c CTKeySort) valuePrimaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValuePrimary); err == nil {
-		return oid, true
-	} else {
-		return primitive.ObjectID{}, false
-	}
-}
-
-func (c CTKeySort) valueSecondaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValueSecondary); err == nil {
-		return oid, true
-	} else {
-		return primitive.ObjectID{}, false
-	}
-}

cursortoken/tokenPaginate.go

@@ -1,41 +0,0 @@
-package cursortoken
-
-import "strconv"
-
-type CTPaginated struct {
-	Mode Mode
-	Page int
-}
-
-func Page(p int) CursorToken {
-	return CTPaginated{
-		Mode: CTMNormal,
-		Page: p,
-	}
-}
-
-func PageEnd() CursorToken {
-	return CTPaginated{
-		Mode: CTMEnd,
-		Page: 0,
-	}
-}
-
-func (c CTPaginated) Token() string {
-	if c.Mode == CTMStart {
-		return "$1"
-	}
-	if c.Mode == CTMEnd {
-		return "$end"
-	}
-
-	return "$" + strconv.Itoa(c.Page)
-}
-
-func (c CTPaginated) IsEnd() bool {
-	return c.Mode == CTMEnd
-}
-
-func (c CTPaginated) IsStart() bool {
-	return c.Mode == CTMStart || c.Page == 1
-}

dataext/bufferedReadCloser.go

@@ -115,9 +115,6 @@ func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
 				return nil, err
 			}
 		}
-		if err := b.Reset(); err != nil {
-			return nil, err
-		}
 		return b.buffer, nil
 
 	case modeSourceFinished:
@@ -134,22 +131,10 @@ func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
 	}
 }
 
-// Reset resets the buffer to the beginning of the buffer.
-// If the original source is partially read, we will finish reading it and fill our buffer
 func (b *bufferedReadCloser) Reset() error {
 	switch b.mode {
 	case modeSourceReading:
-		if b.off == 0 {
-			return nil // nobody has read anything yet
-		}
-		err := b.Close()
-		if err != nil {
-			return err
-		}
-		b.mode = modeBufferReading
-		b.off = 0
-		return nil
-
+		fallthrough
 	case modeSourceFinished:
 		err := b.Close()
 		if err != nil {

dataext/casMutex.go

@@ -1,254 +0,0 @@
-package dataext
-
-import (
-	"context"
-	"golang.org/x/sync/semaphore"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"time"
-	"unsafe"
-)
-
-// from https://github.com/viney-shih/go-lock/blob/2f19fd8ce335e33e0ab9dccb1ff2ce820c3da332/cas.go
-
-// CASMutex is the struct implementing RWMutex with CAS mechanism.
-type CASMutex struct {
-	state     casState
-	turnstile *semaphore.Weighted
-
-	broadcastChan chan struct{}
-	broadcastMut  sync.RWMutex
-}
-
-func NewCASMutex() *CASMutex {
-	return &CASMutex{
-		state:         casStateNoLock,
-		turnstile:     semaphore.NewWeighted(1),
-		broadcastChan: make(chan struct{}),
-	}
-}
-
-type casState int32
-
-const (
-	casStateUndefined casState = iota - 2 // -2
-	casStateWriteLock                     // -1
-	casStateNoLock                        // 0
-	casStateReadLock                      // >= 1
-)
-
-func (m *CASMutex) getState(n int32) casState {
-	switch st := casState(n); {
-	case st == casStateWriteLock:
-		fallthrough
-	case st == casStateNoLock:
-		return st
-	case st >= casStateReadLock:
-		return casStateReadLock
-	default:
-		// actually, it should not happened.
-		return casStateUndefined
-	}
-}
-
-func (m *CASMutex) listen() <-chan struct{} {
-	m.broadcastMut.RLock()
-	defer m.broadcastMut.RUnlock()
-
-	return m.broadcastChan
-}
-
-func (m *CASMutex) broadcast() {
-	newCh := make(chan struct{})
-
-	m.broadcastMut.Lock()
-	ch := m.broadcastChan
-	m.broadcastChan = newCh
-	m.broadcastMut.Unlock()
-
-	close(ch)
-}
-
-func (m *CASMutex) tryLock(ctx context.Context) bool {
-	for {
-		broker := m.listen()
-		if atomic.CompareAndSwapInt32(
-			(*int32)(unsafe.Pointer(&m.state)),
-			int32(casStateNoLock),
-			int32(casStateWriteLock),
-		) {
-			return true
-		}
-
-		if ctx == nil {
-			return false
-		}
-
-		select {
-		case <-ctx.Done():
-			// timeout or cancellation
-			return false
-		case <-broker:
-			// waiting for signal triggered by m.broadcast() and trying again.
-		}
-	}
-}
-
-// TryLockWithContext attempts to acquire the lock, blocking until resources
-// are available or ctx is done (timeout or cancellation).
-func (m *CASMutex) TryLockWithContext(ctx context.Context) bool {
-	if err := m.turnstile.Acquire(ctx, 1); err != nil {
-		// Acquire failed due to timeout or cancellation
-		return false
-	}
-
-	defer m.turnstile.Release(1)
-
-	return m.tryLock(ctx)
-}
-
-// Lock acquires the lock.
-// If it is currently held by others, Lock will wait until it has a chance to acquire it.
-func (m *CASMutex) Lock() {
-	ctx := context.Background()
-
-	m.TryLockWithContext(ctx)
-}
-
-// TryLock attempts to acquire the lock without blocking.
-// Return false if someone is holding it now.
-func (m *CASMutex) TryLock() bool {
-	if !m.turnstile.TryAcquire(1) {
-		return false
-	}
-
-	defer m.turnstile.Release(1)
-
-	return m.tryLock(nil)
-}
-
-// TryLockWithTimeout attempts to acquire the lock within a period of time.
-// Return false if spending time is more than duration and no chance to acquire it.
-func (m *CASMutex) TryLockWithTimeout(duration time.Duration) bool {
-	ctx, cancel := context.WithTimeout(context.Background(), duration)
-	defer cancel()
-
-	return m.TryLockWithContext(ctx)
-}
-
-// Unlock releases the lock.
-func (m *CASMutex) Unlock() {
-	if ok := atomic.CompareAndSwapInt32(
-		(*int32)(unsafe.Pointer(&m.state)),
-		int32(casStateWriteLock),
-		int32(casStateNoLock),
-	); !ok {
-		panic("Unlock failed")
-	}
-
-	m.broadcast()
-}
-
-func (m *CASMutex) rTryLock(ctx context.Context) bool {
-	for {
-		broker := m.listen()
-		n := atomic.LoadInt32((*int32)(unsafe.Pointer(&m.state)))
-		st := m.getState(n)
-		switch st {
-		case casStateNoLock, casStateReadLock:
-			if atomic.CompareAndSwapInt32((*int32)(unsafe.Pointer(&m.state)), n, n+1) {
-				return true
-			}
-		}
-
-		if ctx == nil {
-			return false
-		}
-
-		select {
-		case <-ctx.Done():
-			// timeout or cancellation
-			return false
-		default:
-			switch st {
-			// read-lock failed due to concurrence issue, try again immediately
-			case casStateNoLock, casStateReadLock:
-				runtime.Gosched() // allow other goroutines to do stuff.
-				continue
-			}
-		}
-
-		select {
-		case <-ctx.Done():
-			// timeout or cancellation
-			return false
-		case <-broker:
-			// waiting for signal triggered by m.broadcast() and trying again.
-		}
-	}
-}
-
-// RTryLockWithContext attempts to acquire the read lock, blocking until resources
-// are available or ctx is done (timeout or cancellation).
-func (m *CASMutex) RTryLockWithContext(ctx context.Context) bool {
-	if err := m.turnstile.Acquire(ctx, 1); err != nil {
-		// Acquire failed due to timeout or cancellation
-		return false
-	}
-
-	m.turnstile.Release(1)
-
-	return m.rTryLock(ctx)
-}
-
-// RLock acquires the read lock.
-// If it is currently held by others writing, RLock will wait until it has a chance to acquire it.
-func (m *CASMutex) RLock() {
-	ctx := context.Background()
-
-	m.RTryLockWithContext(ctx)
-}
-
-// RTryLock attempts to acquire the read lock without blocking.
-// Return false if someone is writing it now.
-func (m *CASMutex) RTryLock() bool {
-	if !m.turnstile.TryAcquire(1) {
-		return false
-	}
-
-	m.turnstile.Release(1)
-
-	return m.rTryLock(nil)
-}
-
-// RTryLockWithTimeout attempts to acquire the read lock within a period of time.
-// Return false if spending time is more than duration and no chance to acquire it.
-func (m *CASMutex) RTryLockWithTimeout(duration time.Duration) bool {
-	ctx, cancel := context.WithTimeout(context.Background(), duration)
-	defer cancel()
-
-	return m.RTryLockWithContext(ctx)
-}
-
-// RUnlock releases the read lock.
-func (m *CASMutex) RUnlock() {
-	n := atomic.AddInt32((*int32)(unsafe.Pointer(&m.state)), -1)
-	switch m.getState(n) {
-	case casStateUndefined, casStateWriteLock:
-		panic("RUnlock failed")
-	case casStateNoLock:
-		m.broadcast()
-	}
-}
-
-// RLocker returns a Locker interface that implements the Lock and Unlock methods
-// by calling CASMutex.RLock and CASMutex.RUnlock.
-func (m *CASMutex) RLocker() sync.Locker {
-	return (*rlocker)(m)
-}
-
-type rlocker CASMutex
-
-func (r *rlocker) Lock()   { (*CASMutex)(r).RLock() }
-func (r *rlocker) Unlock() { (*CASMutex)(r).RUnlock() }

dataext/lruMap_test.go

@@ -12,7 +12,7 @@ func init() {
 }
 
 func TestResultCache1(t *testing.T) {
-	cache := NewLRUMap[string, string](8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key := randomKey()
@@ -50,7 +50,7 @@ func TestResultCache1(t *testing.T) {
 }
 
 func TestResultCache2(t *testing.T) {
-	cache := NewLRUMap[string, string](8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -150,7 +150,7 @@ func TestResultCache2(t *testing.T) {
 }
 
 func TestResultCache3(t *testing.T) {
-	cache := NewLRUMap[string, string](8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -173,7 +173,7 @@ func TestResultCache3(t *testing.T) {
 }
 
 // does a basic consistency check over the internal cache representation
-func verifyLRUList[TKey comparable, TData any](cache *LRUMap[TKey, TData], t *testing.T) {
+func verifyLRUList[TData any](cache *LRUMap[TData], t *testing.T) {
 	size := 0
 
 	tailFound := false

dataext/merge_test.go

@@ -2,7 +2,6 @@ package dataext
 
 import (
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 
@@ -44,10 +43,10 @@ func TestObjectMerge(t *testing.T) {
 
 	valueMerge := ObjectMerge(valueA, valueB)
 
-	tst.AssertIdentPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1)
-	tst.AssertIdentPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2)
-	tst.AssertIdentPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3)
-	tst.AssertIdentPtrEqual(t, "Field4", valueMerge.Field4, nil)
+	assertPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1)
+	assertPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2)
+	assertPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3)
+	assertPtrEqual(t, "Field4", valueMerge.Field4, nil)
 
 }
 

dataext/optional.go

@@ -1,83 +0,0 @@
-package dataext
-
-import (
-	"encoding/json"
-	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type JsonOpt[T any] struct {
-	isSet bool
-	value T
-}
-
-func NewJsonOpt[T any](v T) JsonOpt[T] {
-	return JsonOpt[T]{isSet: true, value: v}
-}
-
-func EmptyJsonOpt[T any]() JsonOpt[T] {
-	return JsonOpt[T]{isSet: false}
-}
-
-// MarshalJSON returns m as the JSON encoding of m.
-func (m JsonOpt[T]) MarshalJSON() ([]byte, error) {
-	if !m.isSet {
-		return []byte("null"), nil // actually this would be undefined - but undefined is not valid JSON
-	}
-
-	return json.Marshal(m.value)
-}
-
-// UnmarshalJSON sets *m to a copy of data.
-func (m *JsonOpt[T]) UnmarshalJSON(data []byte) error {
-	if m == nil {
-		return errors.New("JsonOpt: UnmarshalJSON on nil pointer")
-	}
-
-	m.isSet = true
-	return json.Unmarshal(data, &m.value)
-}
-
-func (m JsonOpt[T]) IsSet() bool {
-	return m.isSet
-}
-
-func (m JsonOpt[T]) IsUnset() bool {
-	return !m.isSet
-}
-
-func (m JsonOpt[T]) Value() (T, bool) {
-	if !m.isSet {
-		return *new(T), false
-	}
-	return m.value, true
-}
-
-func (m JsonOpt[T]) ValueOrNil() *T {
-	if !m.isSet {
-		return nil
-	}
-	return &m.value
-}
-
-func (m JsonOpt[T]) ValueDblPtrOrNil() **T {
-	if !m.isSet {
-		return nil
-	}
-	return langext.DblPtr(m.value)
-}
-
-func (m JsonOpt[T]) MustValue() T {
-	if !m.isSet {
-		panic("value not set")
-	}
-	return m.value
-}
-
-func (m JsonOpt[T]) IfSet(fn func(v T)) bool {
-	if !m.isSet {
-		return false
-	}
-	fn(m.value)
-	return true
-}

dataext/ringBuffer.go

@@ -1,144 +0,0 @@
-package dataext
-
-import "iter"
-
-type RingBuffer[T any] struct {
-	items    []T //
-	capacity int // max number of items the buffer can hold
-	size     int // how many items are in the buffer
-	head     int // ptr to next item
-}
-
-func NewRingBuffer[T any](capacity int) *RingBuffer[T] {
-	return &RingBuffer[T]{
-		items:    make([]T, capacity),
-		capacity: capacity,
-		size:     0,
-		head:     0,
-	}
-}
-
-func (rb *RingBuffer[T]) Push(item T) {
-	if rb.size < rb.capacity {
-		rb.size++
-	}
-	rb.items[rb.head] = item
-	rb.head = (rb.head + 1) % rb.capacity
-}
-
-func (rb *RingBuffer[T]) PushPop(item T) *T {
-	if rb.size < rb.capacity {
-		rb.size++
-		rb.items[rb.head] = item
-		rb.head = (rb.head + 1) % rb.capacity
-		return nil
-	} else {
-		prev := rb.items[rb.head]
-		rb.items[rb.head] = item
-		rb.head = (rb.head + 1) % rb.capacity
-		return &prev
-	}
-}
-
-func (rb *RingBuffer[T]) Peek() (T, bool) {
-	if rb.size == 0 {
-		return *new(T), false
-	}
-	return rb.items[(rb.head-1+rb.capacity)%rb.capacity], true
-}
-
-func (rb *RingBuffer[T]) Items() []T {
-	if rb.size < rb.capacity {
-		return rb.items[:rb.size]
-	}
-	return append(rb.items[rb.head:], rb.items[:rb.head]...)
-}
-
-func (rb *RingBuffer[T]) Size() int {
-	return rb.size
-}
-
-func (rb *RingBuffer[T]) Capacity() int {
-	return rb.capacity
-}
-
-func (rb *RingBuffer[T]) Clear() {
-	rb.size = 0
-	rb.head = 0
-}
-
-func (rb *RingBuffer[T]) IsFull() bool {
-	return rb.size == rb.capacity
-}
-
-func (rb *RingBuffer[T]) At(i int) T {
-	if i < 0 || i >= rb.size {
-		panic("Index out of bounds")
-	}
-	if rb.size < rb.capacity {
-		return rb.items[i]
-	}
-	return rb.items[(rb.head+i)%rb.capacity]
-}
-
-func (rb *RingBuffer[T]) Get(i int) (T, bool) {
-	if i < 0 || i >= rb.size {
-		return *new(T), false
-	}
-	if rb.size < rb.capacity {
-		return rb.items[i], true
-	}
-	return rb.items[(rb.head+i)%rb.capacity], true
-}
-
-func (rb *RingBuffer[T]) Iter() iter.Seq[T] {
-	return func(yield func(T) bool) {
-		for i := 0; i < rb.size; i++ {
-			if !yield(rb.At(i)) {
-				return
-			}
-		}
-	}
-}
-
-func (rb *RingBuffer[T]) Iter2() iter.Seq2[int, T] {
-	return func(yield func(int, T) bool) {
-		for i := 0; i < rb.size; i++ {
-			if !yield(i, rb.At(i)) {
-				return
-			}
-		}
-	}
-}
-
-func (rb *RingBuffer[T]) Remove(fnEqual func(v T) bool) int {
-	// Mike [2024-11-13]: I *really* tried to write an in-place algorithm to remove elements
-	//                    But after carful consideration, I left that as an exercise for future readers
-	//                    It is, suprisingly, non-trivial, especially because the head-ptr must be weirdly updated
-	//                    And out At() method does not work correctly with {head<>0 && size<capacity}
-
-	dc := 0
-	b := make([]T, rb.capacity)
-	bsize := 0
-
-	for i := 0; i < rb.size; i++ {
-		comp := rb.At(i)
-		if fnEqual(comp) {
-			dc++
-		} else {
-			b[bsize] = comp
-			bsize++
-		}
-	}
-
-	if dc == 0 {
-		return 0
-	}
-
-	rb.items = b
-	rb.size = bsize
-	rb.head = bsize % rb.capacity
-
-	return dc
-
-}

dataext/ringBuffer_test.go

@@ -1,447 +0,0 @@
-package dataext
-
-import "testing"
-
-func TestRingBufferPushAddsItem(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	if rb.Size() != 1 {
-		t.Errorf("Expected size 1, got %d", rb.Size())
-	}
-	if item, _ := rb.Peek(); item != 1 {
-		t.Errorf("Expected item 1, got %d", item)
-	}
-}
-
-func TestRingBufferPushPopReturnsOldestItem(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	if item := rb.PushPop(4); item == nil || *item != 1 {
-		t.Errorf("Expected item 1, got %v", item)
-	}
-}
-
-func TestRingBufferPeekReturnsLastPushedItem(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	if item, _ := rb.Peek(); item != 2 {
-		t.Errorf("Expected item 2, got %d", item)
-	}
-}
-
-func TestRingBufferOverflow1(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1) // overriden
-	rb.Push(2) // overriden
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	rb.Push(5)
-	rb.Push(7)
-	if rb.Size() != 5 {
-		t.Errorf("Expected size 4, got %d", rb.Size())
-	}
-	expected := []int{3, 9, 4, 5, 7}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferItemsReturnsAllItems(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	items := rb.Items()
-	expected := []int{1, 2, 3}
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferClearEmptiesBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Clear()
-	if rb.Size() != 0 {
-		t.Errorf("Expected size 0, got %d", rb.Size())
-	}
-}
-
-func TestRingBufferIsFullReturnsTrueWhenFull(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	if !rb.IsFull() {
-		t.Errorf("Expected buffer to be full")
-	}
-}
-
-func TestRingBufferAtReturnsCorrectItem(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	if item := rb.At(1); item != 2 {
-		t.Errorf("Expected item 2, got %d", item)
-	}
-}
-
-func TestRingBufferGetReturnsCorrectItem(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	if item, ok := rb.Get(1); !ok || item != 2 {
-		t.Errorf("Expected item 2, got %d", item)
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	rb.Push(2)
-	rb.Push(4)
-	removed := rb.Remove(func(v int) bool { return v == 2 })
-	if removed != 2 {
-		t.Errorf("Expected 2 items removed, got %d", removed)
-	}
-	if rb.Size() != 3 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-	expected := []int{1, 3, 4}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems2(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	rb.Push(2)
-	rb.Push(4)
-	removed := rb.Remove(func(v int) bool { return v == 3 })
-	if removed != 1 {
-		t.Errorf("Expected 2 items removed, got %d", removed)
-	}
-	if rb.Size() != 4 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-	expected := []int{1, 2, 2, 4}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems3(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	removed := rb.Remove(func(v int) bool { return v == 3 })
-	if removed != 1 {
-		t.Errorf("Expected 2 items removed, got %d", removed)
-	}
-	if rb.Size() != 4 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-	expected := []int{1, 2, 9, 4}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems4(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1) // overriden
-	rb.Push(2) // overriden
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	rb.Push(5)
-	rb.Push(7)
-	removed := rb.Remove(func(v int) bool { return v == 7 })
-	if removed != 1 {
-		t.Errorf("Expected 1 items removed, got %d", removed)
-	}
-	if rb.Size() != 4 {
-		t.Errorf("Expected size 4, got %d", rb.Size())
-	}
-	expected := []int{3, 9, 4, 5}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems5(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1) // overriden
-	rb.Push(2) // overriden
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	rb.Push(5)
-	rb.Push(7)
-	removed := rb.Remove(func(v int) bool { return v == 3 })
-	if removed != 1 {
-		t.Errorf("Expected 1 items removed, got %d", removed)
-	}
-	if rb.Size() != 4 {
-		t.Errorf("Expected size 4, got %d", rb.Size())
-	}
-	expected := []int{9, 4, 5, 7}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems6(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1) // overriden
-	rb.Push(2) // overriden
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	rb.Push(5)
-	rb.Push(7)
-	removed := rb.Remove(func(v int) bool { return v == 1 })
-	if removed != 0 {
-		t.Errorf("Expected 0 items removed, got %d", removed)
-	}
-	if rb.Size() != 5 {
-		t.Errorf("Expected size 5, got %d", rb.Size())
-	}
-	expected := []int{3, 9, 4, 5, 7}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-	if !rb.IsFull() {
-		t.Errorf("Expected buffer to not be full")
-	}
-}
-
-func TestRingBufferRemoveDeletesMatchingItems7(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1) // overriden
-	rb.Push(2) // overriden
-	rb.Push(3)
-	rb.Push(9)
-	rb.Push(4)
-	rb.Push(5)
-	rb.Push(7)
-	removed := rb.Remove(func(v int) bool { return v == 9 })
-	if removed != 1 {
-		t.Errorf("Expected 1 items removed, got %d", removed)
-	}
-	if rb.Size() != 4 {
-		t.Errorf("Expected size 4, got %d", rb.Size())
-	}
-	expected := []int{3, 4, 5, 7}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-	if rb.IsFull() {
-		t.Errorf("Expected buffer to not be full")
-	}
-}
-
-func TestRingBufferAddItemsToFullRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	rb.Push(4)
-	if rb.Size() != 3 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-	expected := []int{2, 3, 4}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferAddItemsToNonFullRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	if rb.Size() != 2 {
-		t.Errorf("Expected size 2, got %d", rb.Size())
-	}
-	expected := []int{1, 2}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveItemsFromNonFullRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	removed := rb.Remove(func(v int) bool { return v == 1 })
-	if removed != 1 {
-		t.Errorf("Expected 1 item removed, got %d", removed)
-	}
-	if rb.Size() != 1 {
-		t.Errorf("Expected size 1, got %d", rb.Size())
-	}
-	expected := []int{2}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveItemsFromFullRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	removed := rb.Remove(func(v int) bool { return v == 2 })
-	if removed != 1 {
-		t.Errorf("Expected 1 item removed, got %d", removed)
-	}
-	if rb.Size() != 2 {
-		t.Errorf("Expected size 2, got %d", rb.Size())
-	}
-	expected := []int{1, 3}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveMultipleItemsFromRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](5)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	rb.Push(2)
-	rb.Push(4)
-	removed := rb.Remove(func(v int) bool { return v == 2 })
-	if removed != 2 {
-		t.Errorf("Expected 2 items removed, got %d", removed)
-	}
-	if rb.Size() != 3 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-	expected := []int{1, 3, 4}
-	items := rb.Items()
-	for i, item := range items {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-	}
-}
-
-func TestRingBufferRemoveAllItemsFromRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	removed := rb.Remove(func(v int) bool { return true })
-	if removed != 3 {
-		t.Errorf("Expected 3 items removed, got %d", removed)
-	}
-	if rb.Size() != 0 {
-		t.Errorf("Expected size 0, got %d", rb.Size())
-	}
-}
-
-func TestRingBufferRemoveNoItemsFromRingBuffer(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	removed := rb.Remove(func(v int) bool { return false })
-	if removed != 0 {
-		t.Errorf("Expected 0 items removed, got %d", removed)
-	}
-	if rb.Size() != 3 {
-		t.Errorf("Expected size 3, got %d", rb.Size())
-	}
-}
-
-func TestRingBufferIteratesOverAllItems(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	expected := []int{1, 2, 3}
-	i := 0
-	for item := range rb.Iter() {
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-		i++
-	}
-	if i != len(expected) {
-		t.Errorf("Expected to iterate over %d items, but iterated over %d", len(expected), i)
-	}
-}
-
-func TestRingBufferIter2IteratesOverAllItemsWithIndices(t *testing.T) {
-	rb := NewRingBuffer[int](3)
-	rb.Push(1)
-	rb.Push(2)
-	rb.Push(3)
-	expected := []int{1, 2, 3}
-	i := 0
-	for index, item := range rb.Iter2() {
-		if index != i {
-			t.Errorf("Expected index %d, got %d", i, index)
-		}
-		if item != expected[i] {
-			t.Errorf("Expected item %d, got %d", expected[i], item)
-		}
-		i++
-	}
-	if i != len(expected) {
-		t.Errorf("Expected to iterate over %d items, but iterated over %d", len(expected), i)
-	}
-}

dataext/structHash_test.go

@@ -1,8 +1,8 @@
 package dataext
 
 import (
+	"encoding/hex"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 
@@ -18,14 +18,14 @@ func noErrStructHash(t *testing.T, dat any, opt ...StructHashOptions) []byte {
 
 func TestStructHashSimple(t *testing.T) {
 
-	tst.AssertHexEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello"))
-	tst.AssertHexEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0))
-	tst.AssertHexEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{}))
-	tst.AssertHexEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{}))
-	tst.AssertHexEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3}))
-	tst.AssertHexEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil))
-	tst.AssertHexEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil}))
-	tst.AssertHexEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{}))
+	assertEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello"))
+	assertEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0))
+	assertEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{}))
+	assertEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{}))
+	assertEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3}))
+	assertEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil))
+	assertEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil}))
+	assertEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{}))
 
 }
 
@@ -37,13 +37,13 @@ func TestStructHashSimpleStruct(t *testing.T) {
 		F3 *int
 	}
 
-	tst.AssertHexEqual(t, "a90bff751c70c738bb5cfc9b108e783fa9c19c0bc9273458e0aaee6e74aa1b92", noErrStructHash(t, t0{
+	assertEqual(t, "a90bff751c70c738bb5cfc9b108e783fa9c19c0bc9273458e0aaee6e74aa1b92", noErrStructHash(t, t0{
 		F1: 10,
 		F2: []string{"1", "2", "3"},
 		F3: nil,
 	}))
 
-	tst.AssertHexEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{
+	assertEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{
 		F1: 10,
 		F2: []string{"1", "2", "3"},
 		F3: langext.Ptr(99),
@@ -64,7 +64,7 @@ func TestStructHashLayeredStruct(t *testing.T) {
 		SV3 t1_1
 	}
 
-	tst.AssertHexEqual(t, "fd4ca071fb40a288fee4b7a3dfdaab577b30cb8f80f81ec511e7afd72dc3b469", noErrStructHash(t, t1_2{
+	assertEqual(t, "fd4ca071fb40a288fee4b7a3dfdaab577b30cb8f80f81ec511e7afd72dc3b469", noErrStructHash(t, t1_2{
 		SV1: nil,
 		SV2: nil,
 		SV3: t1_1{
@@ -73,7 +73,7 @@ func TestStructHashLayeredStruct(t *testing.T) {
 			F15: false,
 		},
 	}))
-	tst.AssertHexEqual(t, "3fbf7c67d8121deda075cc86319a4e32d71744feb2cebf89b43bc682f072a029", noErrStructHash(t, t1_2{
+	assertEqual(t, "3fbf7c67d8121deda075cc86319a4e32d71744feb2cebf89b43bc682f072a029", noErrStructHash(t, t1_2{
 		SV1: nil,
 		SV2: &t1_1{},
 		SV3: t1_1{
@@ -82,7 +82,7 @@ func TestStructHashLayeredStruct(t *testing.T) {
 			F15: true,
 		},
 	}))
-	tst.AssertHexEqual(t, "b1791ccd1b346c3ede5bbffda85555adcd8216b93ffca23f14fe175ec47c5104", noErrStructHash(t, t1_2{
+	assertEqual(t, "b1791ccd1b346c3ede5bbffda85555adcd8216b93ffca23f14fe175ec47c5104", noErrStructHash(t, t1_2{
 		SV1: &t1_1{},
 		SV2: &t1_1{},
 		SV3: t1_1{
@@ -101,7 +101,7 @@ func TestStructHashMap(t *testing.T) {
 		F2 map[string]int
 	}
 
-	tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
 		F1: 10,
 		F2: map[string]int{
 			"x": 1,
@@ -110,7 +110,7 @@ func TestStructHashMap(t *testing.T) {
 		},
 	}))
 
-	tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
 		F1: 10,
 		F2: map[string]int{
 			"a": 99,
@@ -128,9 +128,16 @@ func TestStructHashMap(t *testing.T) {
 	m3["x"] = 1
 	m3["a"] = 2
 
-	tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
+	assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{
 		F1: 10,
 		F2: m3,
 	}))
 
 }
+
+func assertEqual(t *testing.T, expected string, actual []byte) {
+	actualStr := hex.EncodeToString(actual)
+	if actualStr != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actualStr, expected)
+	}
+}

dataext/syncMap.go

@@ -1,167 +0,0 @@
-package dataext
-
-import "sync"
-
-type SyncMap[TKey comparable, TData any] struct {
-	data map[TKey]TData
-	lock sync.Mutex
-}
-
-func NewSyncMap[TKey comparable, TData any]() *SyncMap[TKey, TData] {
-	return &SyncMap[TKey, TData]{data: make(map[TKey]TData), lock: sync.Mutex{}}
-}
-
-func (s *SyncMap[TKey, TData]) Set(key TKey, data TData) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	s.data[key] = data
-}
-
-func (s *SyncMap[TKey, TData]) SetIfNotContains(key TKey, data TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	if _, existsInPreState := s.data[key]; existsInPreState {
-		return false
-	}
-
-	s.data[key] = data
-
-	return true
-}
-
-func (s *SyncMap[TKey, TData]) SetIfNotContainsFunc(key TKey, data func() TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	if _, existsInPreState := s.data[key]; existsInPreState {
-		return false
-	}
-
-	s.data[key] = data()
-
-	return true
-}
-
-func (s *SyncMap[TKey, TData]) Get(key TKey) (TData, bool) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	if v, ok := s.data[key]; ok {
-		return v, true
-	} else {
-		return *new(TData), false
-	}
-}
-
-func (s *SyncMap[TKey, TData]) GetAndSetIfNotContains(key TKey, data TData) TData {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	if v, ok := s.data[key]; ok {
-		return v
-	} else {
-		s.data[key] = data
-		return data
-	}
-}
-
-func (s *SyncMap[TKey, TData]) GetAndSetIfNotContainsFunc(key TKey, data func() TData) TData {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	if v, ok := s.data[key]; ok {
-		return v
-	} else {
-		dataObj := data()
-		s.data[key] = dataObj
-		return dataObj
-	}
-}
-
-func (s *SyncMap[TKey, TData]) Delete(key TKey) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	_, ok := s.data[key]
-
-	delete(s.data, key)
-
-	return ok
-}
-
-func (s *SyncMap[TKey, TData]) Contains(key TKey) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	_, ok := s.data[key]
-
-	return ok
-}
-
-func (s *SyncMap[TKey, TData]) GetAllKeys() []TKey {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	r := make([]TKey, 0, len(s.data))
-
-	for k := range s.data {
-		r = append(r, k)
-	}
-
-	return r
-}
-
-func (s *SyncMap[TKey, TData]) GetAllValues() []TData {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TKey]TData)
-	}
-
-	r := make([]TData, 0, len(s.data))
-
-	for _, v := range s.data {
-		r = append(r, v)
-	}
-
-	return r
-}

dataext/syncRingSet.go

@@ -1,143 +0,0 @@
-package dataext
-
-import "sync"
-
-type SyncRingSet[TData comparable] struct {
-	data map[TData]bool
-	lock sync.Mutex
-	ring *RingBuffer[TData]
-}
-
-func NewSyncRingSet[TData comparable](capacity int) *SyncRingSet[TData] {
-	return &SyncRingSet[TData]{
-		data: make(map[TData]bool, capacity+1),
-		lock: sync.Mutex{},
-		ring: NewRingBuffer[TData](capacity),
-	}
-}
-
-// Add adds `value` to the set
-// returns true  if the value was actually inserted (value did not exist beforehand)
-// returns false if the value already existed
-func (s *SyncRingSet[TData]) Add(value TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	_, existsInPreState := s.data[value]
-	if existsInPreState {
-		return false
-	}
-
-	prev := s.ring.PushPop(value)
-
-	s.data[value] = true
-	if prev != nil {
-		delete(s.data, *prev)
-	}
-
-	return true
-}
-
-func (s *SyncRingSet[TData]) AddAll(values []TData) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	for _, value := range values {
-		_, existsInPreState := s.data[value]
-		if existsInPreState {
-			continue
-		}
-
-		prev := s.ring.PushPop(value)
-
-		s.data[value] = true
-		if prev != nil {
-			delete(s.data, *prev)
-		}
-	}
-}
-
-func (s *SyncRingSet[TData]) Remove(value TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	_, existsInPreState := s.data[value]
-	if !existsInPreState {
-		return false
-	}
-
-	delete(s.data, value)
-	s.ring.Remove(func(v TData) bool { return value == v })
-
-	return true
-}
-
-func (s *SyncRingSet[TData]) RemoveAll(values []TData) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	for _, value := range values {
-		delete(s.data, value)
-		s.ring.Remove(func(v TData) bool { return value == v })
-	}
-}
-
-func (s *SyncRingSet[TData]) Contains(value TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	_, ok := s.data[value]
-
-	return ok
-}
-
-func (s *SyncRingSet[TData]) Get() []TData {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	r := make([]TData, 0, len(s.data))
-
-	for k := range s.data {
-		r = append(r, k)
-	}
-
-	return r
-}
-
-// AddIfNotContains
-// returns true  if the value was actually added (value did not exist beforehand)
-// returns false if the value already existed
-func (s *SyncRingSet[TData]) AddIfNotContains(key TData) bool {
-	return s.Add(key)
-}
-
-// RemoveIfContains
-// returns true  if the value was actually removed (value did exist beforehand)
-// returns false if the value did not exist in the set
-func (s *SyncRingSet[TData]) RemoveIfContains(key TData) bool {
-	return s.Remove(key)
-}

dataext/syncSet.go

@@ -7,13 +7,6 @@ type SyncSet[TData comparable] struct {
 	lock sync.Mutex
 }
 
-func NewSyncSet[TData comparable]() *SyncSet[TData] {
-	return &SyncSet[TData]{data: make(map[TData]bool), lock: sync.Mutex{}}
-}
-
-// Add adds `value` to the set
-// returns true  if the value was actually inserted (value did not exist beforehand)
-// returns false if the value already existed
 func (s *SyncSet[TData]) Add(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -22,13 +15,10 @@ func (s *SyncSet[TData]) Add(value TData) bool {
 		s.data = make(map[TData]bool)
 	}
 
-	_, existsInPreState := s.data[value]
-	if existsInPreState {
-		return false
-	}
-
+	_, ok := s.data[value]
 	s.data[value] = true
-	return true
+
+	return !ok
 }
 
 func (s *SyncSet[TData]) AddAll(values []TData) {
@@ -44,36 +34,6 @@ func (s *SyncSet[TData]) AddAll(values []TData) {
 	}
 }
 
-func (s *SyncSet[TData]) Remove(value TData) bool {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	_, existsInPreState := s.data[value]
-	if !existsInPreState {
-		return false
-	}
-
-	delete(s.data, value)
-	return true
-}
-
-func (s *SyncSet[TData]) RemoveAll(values []TData) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if s.data == nil {
-		s.data = make(map[TData]bool)
-	}
-
-	for _, value := range values {
-		delete(s.data, value)
-	}
-}
-
 func (s *SyncSet[TData]) Contains(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -103,17 +63,3 @@ func (s *SyncSet[TData]) Get() []TData {
 
 	return r
 }
-
-// AddIfNotContains
-// returns true  if the value was actually added (value did not exist beforehand)
-// returns false if the value already existed
-func (s *SyncSet[TData]) AddIfNotContains(key TData) bool {
-	return s.Add(key)
-}
-
-// RemoveIfContains
-// returns true  if the value was actually removed (value did exist beforehand)
-// returns false if the value did not exist in the set
-func (s *SyncSet[TData]) RemoveIfContains(key TData) bool {
-	return s.Remove(key)
-}

dataext/tuple.go

@@ -1,241 +0,0 @@
-package dataext
-
-type ValueGroup interface {
-	TupleLength() int
-	TupleValues() []any
-}
-
-// ----------------------------------------------------------------------------
-
-type Single[T1 any] struct {
-	V1 T1
-}
-
-func (s Single[T1]) TupleLength() int {
-	return 1
-}
-
-func (s Single[T1]) TupleValues() []any {
-	return []any{s.V1}
-}
-
-func NewSingle[T1 any](v1 T1) Single[T1] {
-	return Single[T1]{V1: v1}
-}
-
-func NewTuple1[T1 any](v1 T1) Single[T1] {
-	return Single[T1]{V1: v1}
-}
-
-// ----------------------------------------------------------------------------
-
-type Tuple[T1 any, T2 any] struct {
-	V1 T1
-	V2 T2
-}
-
-func (t Tuple[T1, T2]) TupleLength() int {
-	return 2
-}
-
-func (t Tuple[T1, T2]) TupleValues() []any {
-	return []any{t.V1, t.V2}
-}
-
-func NewTuple[T1 any, T2 any](v1 T1, v2 T2) Tuple[T1, T2] {
-	return Tuple[T1, T2]{V1: v1, V2: v2}
-}
-
-func NewTuple2[T1 any, T2 any](v1 T1, v2 T2) Tuple[T1, T2] {
-	return Tuple[T1, T2]{V1: v1, V2: v2}
-}
-
-// ----------------------------------------------------------------------------
-
-type Triple[T1 any, T2 any, T3 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-}
-
-func (t Triple[T1, T2, T3]) TupleLength() int {
-	return 3
-}
-
-func (t Triple[T1, T2, T3]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3}
-}
-
-func NewTriple[T1 any, T2 any, T3 any](v1 T1, v2 T2, v3 T3) Triple[T1, T2, T3] {
-	return Triple[T1, T2, T3]{V1: v1, V2: v2, V3: v3}
-}
-
-func NewTuple3[T1 any, T2 any, T3 any](v1 T1, v2 T2, v3 T3) Triple[T1, T2, T3] {
-	return Triple[T1, T2, T3]{V1: v1, V2: v2, V3: v3}
-}
-
-// ----------------------------------------------------------------------------
-
-type Quadruple[T1 any, T2 any, T3 any, T4 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-}
-
-func (t Quadruple[T1, T2, T3, T4]) TupleLength() int {
-	return 4
-}
-
-func (t Quadruple[T1, T2, T3, T4]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4}
-}
-
-func NewQuadruple[T1 any, T2 any, T3 any, T4 any](v1 T1, v2 T2, v3 T3, v4 T4) Quadruple[T1, T2, T3, T4] {
-	return Quadruple[T1, T2, T3, T4]{V1: v1, V2: v2, V3: v3, V4: v4}
-}
-
-func NewTuple4[T1 any, T2 any, T3 any, T4 any](v1 T1, v2 T2, v3 T3, v4 T4) Quadruple[T1, T2, T3, T4] {
-	return Quadruple[T1, T2, T3, T4]{V1: v1, V2: v2, V3: v3, V4: v4}
-}
-
-// ----------------------------------------------------------------------------
-
-type Quintuple[T1 any, T2 any, T3 any, T4 any, T5 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-	V5 T5
-}
-
-func (t Quintuple[T1, T2, T3, T4, T5]) TupleLength() int {
-	return 5
-}
-
-func (t Quintuple[T1, T2, T3, T4, T5]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4, t.V5}
-
-}
-
-func NewQuintuple[T1 any, T2 any, T3 any, T4 any, T5 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) Quintuple[T1, T2, T3, T4, T5] {
-	return Quintuple[T1, T2, T3, T4, T5]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5}
-}
-
-func NewTuple5[T1 any, T2 any, T3 any, T4 any, T5 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) Quintuple[T1, T2, T3, T4, T5] {
-	return Quintuple[T1, T2, T3, T4, T5]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5}
-}
-
-// ----------------------------------------------------------------------------
-
-type Sextuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-	V5 T5
-	V6 T6
-}
-
-func (t Sextuple[T1, T2, T3, T4, T5, T6]) TupleLength() int {
-	return 6
-}
-
-func (t Sextuple[T1, T2, T3, T4, T5, T6]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6}
-
-}
-
-func NewSextuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) Sextuple[T1, T2, T3, T4, T5, T6] {
-	return Sextuple[T1, T2, T3, T4, T5, T6]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6}
-}
-
-func NewTuple6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) Sextuple[T1, T2, T3, T4, T5, T6] {
-	return Sextuple[T1, T2, T3, T4, T5, T6]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6}
-}
-
-// ----------------------------------------------------------------------------
-
-type Septuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-	V5 T5
-	V6 T6
-	V7 T7
-}
-
-func (t Septuple[T1, T2, T3, T4, T5, T6, T7]) TupleLength() int {
-	return 7
-}
-
-func (t Septuple[T1, T2, T3, T4, T5, T6, T7]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7}
-}
-
-func NewSeptuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) Septuple[T1, T2, T3, T4, T5, T6, T7] {
-	return Septuple[T1, T2, T3, T4, T5, T6, T7]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7}
-}
-
-func NewTuple7[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) Septuple[T1, T2, T3, T4, T5, T6, T7] {
-	return Septuple[T1, T2, T3, T4, T5, T6, T7]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7}
-}
-
-// ----------------------------------------------------------------------------
-
-type Octuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-	V5 T5
-	V6 T6
-	V7 T7
-	V8 T8
-}
-
-func (t Octuple[T1, T2, T3, T4, T5, T6, T7, T8]) TupleLength() int {
-	return 8
-}
-
-func (t Octuple[T1, T2, T3, T4, T5, T6, T7, T8]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8}
-}
-
-func NewOctuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) Octuple[T1, T2, T3, T4, T5, T6, T7, T8] {
-	return Octuple[T1, T2, T3, T4, T5, T6, T7, T8]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8}
-}
-
-func NewTuple8[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) Octuple[T1, T2, T3, T4, T5, T6, T7, T8] {
-	return Octuple[T1, T2, T3, T4, T5, T6, T7, T8]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8}
-}
-
-// ----------------------------------------------------------------------------
-
-type Nonuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any] struct {
-	V1 T1
-	V2 T2
-	V3 T3
-	V4 T4
-	V5 T5
-	V6 T6
-	V7 T7
-	V8 T8
-	V9 T9
-}
-
-func (t Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]) TupleLength() int {
-	return 9
-}
-
-func (t Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]) TupleValues() []any {
-	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8, t.V9}
-}
-
-func NewNonuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-	return Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8, V9: v9}
-}
-func NewTuple9[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
-	return Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8, V9: v9}
-}

enums/enum.go

@@ -1,33 +0,0 @@
-package enums
-
-type Enum interface {
-	Valid() bool
-	ValuesAny() []any
-	ValuesMeta() []EnumMetaValue
-	VarName() string
-	TypeName() string
-	PackageName() string
-}
-
-type StringEnum interface {
-	Enum
-	String() string
-}
-
-type DescriptionEnum interface {
-	Enum
-	Description() string
-	DescriptionMeta() EnumDescriptionMetaValue
-}
-
-type EnumMetaValue struct {
-	VarName     string  `json:"varName"`
-	Value       Enum    `json:"value"`
-	Description *string `json:"description"`
-}
-
-type EnumDescriptionMetaValue struct {
-	VarName     string `json:"varName"`
-	Value       Enum   `json:"value"`
-	Description string `json:"description"`
-}

exerr/builder.go

@@ -2,14 +2,10 @@ package exerr
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog"
 	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/enums"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"os"
@@ -21,25 +17,21 @@ import (
 //
 // ==== USAGE =====
 //
-// If some method returns an error _always wrap it into an exerror:
+// If some method returns an error _always wrap it into an bmerror:
 //     value, err := do_something(..)
 //     if err != nil {
-//         return nil, exerror.Wrap(err, "do something failed").Build()
+//         return nil, bmerror.Wrap(err, "do something failed").Build()
 //     }
 //
 // If possible add metadata to the error (eg the id that was not found, ...), the methods are the same as in zerolog
-//     return nil, exerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
-//
-// You can also add extra-data to an error with Extra(..)
-// in contrast to metadata is extradata always printed in the resulting error and is more intended for additional (programmatically readable) data in addition to the errortype
-// (metadata is more internal debug info/help)
+//     return nil, bmerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
 //
 // You can change the errortype with `.User()` and `.System()` (User-errors are 400 and System-errors 500)
 // You can also manually set the statuscode with `.WithStatuscode(http.NotFound)`
 // You can set the type with `WithType(..)`
 //
 // New Errors (that don't wrap an existing err object) are created with New
-//     return nil, exerror.New(exerror.TypeInternal, "womethign wen horrible wrong").Build()
+//     return nil, bmerror.New(bmerror.ErrInternal, "womethign wen horrible wrong").Build()
 // You can eitehr use an existing ErrorType, the "catch-all" ErrInternal, or add you own ErrType in consts.go
 //
 // All errors should be handled one of the following four ways:
@@ -59,51 +51,50 @@ import (
 //     => Wrap/New + Fatal
 //
 
+var stackSkipLogger zerolog.Logger
+
+func init() {
+	cw := zerolog.ConsoleWriter{
+		Out:        os.Stdout,
+		TimeFormat: "2006-01-02 15:04:05 Z07:00",
+	}
+
+	multi := zerolog.MultiLevelWriter(cw)
+	stackSkipLogger = zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
+}
+
 type Builder struct {
-	wrappedErr          error
-	errorData           *ExErr
+	bmerror *bringmanError
+
 	containsGinData bool
-	containsContextData bool
-	noLog               bool
 }
 
 func Get(err error) *Builder {
-	return &Builder{errorData: FromError(err)}
+	return &Builder{bmerror: fromError(err)}
 }
 
 func New(t ErrorType, msg string) *Builder {
-	return &Builder{errorData: newExErr(CatSystem, t, msg)}
+	return &Builder{bmerror: newBringmanErr(CatSystem, t, msg)}
 }
 
 func Wrap(err error, msg string) *Builder {
-	if err == nil {
-		return &Builder{errorData: newExErr(CatSystem, TypeInternal, msg)} // prevent NPE if we call Wrap with err==nil
-	}
-
-	v := FromError(err)
-
-	if !pkgconfig.RecursiveErrors {
-		v.Message = msg
-		return &Builder{wrappedErr: err, errorData: v}
-	} else {
-		return &Builder{wrappedErr: err, errorData: wrapExErr(v, msg, CatWrap, 1)}
-	}
+	return &Builder{bmerror: fromError(err).wrap(msg, CatWrap, 1)}
 }
 
 // ----------------------------------------------------------------------------
 
 func (b *Builder) WithType(t ErrorType) *Builder {
-	b.errorData.Type = t
+	b.bmerror.Type = t
 	return b
 }
 
 func (b *Builder) WithStatuscode(status int) *Builder {
-	b.errorData.StatusCode = &status
+	b.bmerror.StatusCode = status
 	return b
 }
 
 func (b *Builder) WithMessage(msg string) *Builder {
-	b.errorData.Message = msg
+	b.bmerror.Message = msg
 	return b
 }
 
@@ -128,7 +119,7 @@ func (b *Builder) WithMessage(msg string) *Builder {
 //
 //   - Send to the error-service
 func (b *Builder) Err() *Builder {
-	b.errorData.Severity = SevErr
+	b.bmerror.Severity = SevErr
 	return b
 }
 
@@ -147,7 +138,7 @@ func (b *Builder) Err() *Builder {
 //
 //   - Logged as Warn
 func (b *Builder) Warn() *Builder {
-	b.errorData.Severity = SevWarn
+	b.bmerror.Severity = SevWarn
 	return b
 }
 
@@ -166,7 +157,7 @@ func (b *Builder) Warn() *Builder {
 //
 //   - -(nothing)-
 func (b *Builder) Info() *Builder {
-	b.errorData.Severity = SevInfo
+	b.bmerror.Severity = SevInfo
 	return b
 }
 
@@ -176,19 +167,12 @@ func (b *Builder) Info() *Builder {
 //
 // Errors with category
 func (b *Builder) User() *Builder {
-	b.errorData.Category = CatUser
+	b.bmerror.Category = CatUser
 	return b
 }
 
 func (b *Builder) System() *Builder {
-	b.errorData.Category = CatSystem
-	return b
-}
-
-// ----------------------------------------------------------------------------
-
-func (b *Builder) NoLog() *Builder {
-	b.noLog = true
+	b.bmerror.Category = CatSystem
 	return b
 }
 
@@ -278,25 +262,13 @@ func (b *Builder) Any(key string, val any) *Builder {
 	return b.addMeta(key, MDTAny, newAnyWrap(val))
 }
 
-func (b *Builder) Stringer(key string, val fmt.Stringer) *Builder {
-	if langext.IsNil(val) {
-		return b.addMeta(key, MDTString, "(!nil)")
-	} else {
-		return b.addMeta(key, MDTString, val.String())
-	}
-}
-
-func (b *Builder) Enum(key string, val enums.Enum) *Builder {
-	return b.addMeta(key, MDTEnum, newEnumWrap(val))
-}
-
 func (b *Builder) Stack() *Builder {
 	return b.addMeta("@Stack", MDTString, string(debug.Stack()))
 }
 
 func (b *Builder) Errs(key string, val []error) *Builder {
 	for i, valerr := range val {
-		b.addMeta(fmt.Sprintf("%v[%v]", key, i), MDTString, Get(valerr).errorData.FormatLog(LogPrintFull))
+		b.addMeta(fmt.Sprintf("%v[%v]", key, i), MDTString, Get(valerr).toBMError().FormatLog(LogPrintFull))
 	}
 	return b
 }
@@ -304,85 +276,68 @@ func (b *Builder) Errs(key string, val []error) *Builder {
 func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request) *Builder {
 	if v := ctx.Value("start_timestamp"); v != nil {
 		if t, ok := v.(time.Time); ok {
-			b.Time("ctx_startTimestamp", t)
-			b.Time("ctx_endTimestamp", time.Now())
+			b.Time("ctx.startTimestamp", t)
+			b.Time("ctx.endTimestamp", time.Now())
 		}
 	}
-	b.Str("gin_method", req.Method)
-	b.Str("gin_path", g.FullPath())
-	b.Strs("gin_header", extractHeader(g.Request.Header))
+	b.Str("gin.method", req.Method)
+	b.Str("gin.path", g.FullPath())
+	b.Str("gin.header", formatHeader(g.Request.Header))
 	if req.URL != nil {
-		b.Str("gin_url", req.URL.String())
+		b.Str("gin.url", req.URL.String())
 	}
 	if ctxVal := g.GetString("apiversion"); ctxVal != "" {
-		b.Str("gin_context_apiversion", ctxVal)
+		b.Str("gin.context.apiversion", ctxVal)
 	}
 	if ctxVal := g.GetString("uid"); ctxVal != "" {
-		b.Str("gin_context_uid", ctxVal)
+		b.Str("gin.context.uid", ctxVal)
 	}
 	if ctxVal := g.GetString("fcmId"); ctxVal != "" {
-		b.Str("gin_context_fcmid", ctxVal)
+		b.Str("gin.context.fcmid", ctxVal)
 	}
 	if ctxVal := g.GetString("reqid"); ctxVal != "" {
-		b.Str("gin_context_reqid", ctxVal)
+		b.Str("gin.context.reqid", ctxVal)
 	}
-	if req.Method != "GET" && req.Body != nil {
-
-		if req.Header.Get("Content-Type") == "application/json" {
-			if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
+	if req.Method != "GET" && req.Body != nil && req.Header.Get("Content-Type") == "application/json" {
+		if brc, ok := req.Body.(langext.BufferedReadCloser); ok {
 			if bin, err := brc.BufferedAll(); err == nil {
 				if len(bin) < 16*1024 {
 					var prettyJSON bytes.Buffer
 					err = json.Indent(&prettyJSON, bin, "", "  ")
 					if err == nil {
-							b.Str("gin_body", string(prettyJSON.Bytes()))
+						b.Str("gin.body", string(prettyJSON.Bytes()))
 					} else {
-							b.Bytes("gin_body", bin)
+						b.Bytes("gin.body", bin)
 					}
 				} else {
-						b.Str("gin_body", fmt.Sprintf("[[%v bytes | %s]]", len(bin), req.Header.Get("Content-Type")))
+					b.Str("gin.body", fmt.Sprintf("[[%v bytes]]", len(bin)))
 				}
 			}
 		}
 	}
 
-		if req.Header.Get("Content-Type") == "multipart/form-data" || req.Header.Get("Content-Type") == "x-www-form-urlencoded" {
-			if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
-				if bin, err := brc.BufferedAll(); err == nil {
-					if len(bin) < 16*1024 {
-						b.Bytes("gin_body", bin)
-					} else {
-						b.Str("gin_body", fmt.Sprintf("[[%v bytes | %s]]", len(bin), req.Header.Get("Content-Type")))
-					}
-				}
-			}
-		}
-
-	}
-
-	pkgconfig.ExtendGinMeta(ctx, b, g, req)
-
 	b.containsGinData = true
 	return b
 }
 
-func (b *Builder) CtxData(method Method, ctx context.Context) *Builder {
-	pkgconfig.ExtendContextMeta(b, method, ctx)
-
-	b.containsContextData = true
-
-	return b
-}
-
-func extractHeader(header map[string][]string) []string {
-	r := make([]string, 0, len(header))
+func formatHeader(header map[string][]string) string {
+	ml := 1
+	for k, _ := range header {
+		if len(k) > ml {
+			ml = len(k)
+		}
+	}
+	r := ""
 	for k, v := range header {
+		if r != "" {
+			r += "\n"
+		}
 		for _, hval := range v {
 			value := hval
 			value = strings.ReplaceAll(value, "\n", "\\n")
 			value = strings.ReplaceAll(value, "\r", "\\r")
 			value = strings.ReplaceAll(value, "\t", "\\t")
-			r = append(r, k+": "+value)
+			r += langext.StrPadRight(k, " ", ml) + " := " + value
 		}
 	}
 	return r
@@ -390,40 +345,16 @@ func extractHeader(header map[string][]string) []string {
 
 // ----------------------------------------------------------------------------
 
-// Extra adds additional data to the error
-// this is not like the other metadata (like Id(), Str(), etc)
-// this data is public and will be printed/outputted
-func (b *Builder) Extra(key string, val any) *Builder {
-	b.errorData.Extra[key] = val
-	return b
-}
-
-// ----------------------------------------------------------------------------
-
 // Build creates a new error, ready to pass up the stack
 // If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
-// Can be gloablly configured with ZeroLogErrTraces and ZeroLogAllTraces
-// Can be locally suppressed with Builder.NoLog()
-func (b *Builder) Build(ctxs ...context.Context) error {
-	warnOnPkgConfigNotInitialized()
-
-	for _, dctx := range ctxs {
-		b.CtxData(MethodBuild, dctx)
+func (b *Builder) Build() error {
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.ShortLog(stackSkipLogger.Error())
 	}
 
-	if pkgconfig.DisableErrorWrapping && b.wrappedErr != nil {
-		return b.wrappedErr
-	}
+	b.CallListener(MethodBuild)
 
-	if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
-	} else if pkgconfig.ZeroLogAllTraces && !b.noLog {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
-	}
-
-	b.errorData.CallListener(MethodBuild)
-
-	return b.errorData
+	return b.bmerror.ToGrpcError()
 }
 
 // Output prints the error onto the gin stdout.
@@ -435,60 +366,40 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 		b.GinReq(ctx, g, g.Request)
 	}
 
-	b.CtxData(MethodOutput, ctx)
+	b.bmerror.Output(ctx, g)
 
-	b.errorData.Output(g)
-
-	if (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) && (pkgconfig.ZeroLogErrGinOutput || pkgconfig.ZeroLogAllGinOutput) {
-		b.errorData.Log(pkgconfig.ZeroLogger.Error())
-	} else if (b.errorData.Severity == SevWarn) && (pkgconfig.ZeroLogAllGinOutput) {
-		b.errorData.Log(pkgconfig.ZeroLogger.Warn())
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.Log(stackSkipLogger.Error())
+	} else if b.bmerror.Severity == SevWarn {
+		b.bmerror.Log(stackSkipLogger.Warn())
 	}
 
-	b.errorData.CallListener(MethodOutput)
+	b.CallListener(MethodOutput)
 }
 
 // Print prints the error
 // If the error is SevErr we also send it to the error-service
-func (b *Builder) Print(ctxs ...context.Context) Proxy {
-	warnOnPkgConfigNotInitialized()
-
-	for _, dctx := range ctxs {
-		b.CtxData(MethodPrint, dctx)
+func (b *Builder) Print() {
+	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+		b.bmerror.Log(stackSkipLogger.Error())
+	} else if b.bmerror.Severity == SevWarn {
+		b.bmerror.ShortLog(stackSkipLogger.Warn())
 	}
 
-	if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
-		b.errorData.Log(pkgconfig.ZeroLogger.Error())
-	} else if b.errorData.Severity == SevWarn {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
-	} else if b.errorData.Severity == SevInfo {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
-	} else {
-		b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
-	}
-
-	b.errorData.CallListener(MethodPrint)
-
-	return Proxy{v: *b.errorData} // we return Proxy<Exerr> here instead of Exerr to prevent warnings on ignored err-returns
+	b.CallListener(MethodPrint)
 }
 
 func (b *Builder) Format(level LogPrintLevel) string {
-	return b.errorData.FormatLog(level)
+	return b.bmerror.FormatLog(level)
 }
 
 // Fatal prints the error and terminates the program
 // If the error is SevErr we also send it to the error-service
-func (b *Builder) Fatal(ctxs ...context.Context) {
+func (b *Builder) Fatal() {
+	b.bmerror.Severity = SevFatal
+	b.bmerror.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
 
-	b.errorData.Severity = SevFatal
-
-	for _, dctx := range ctxs {
-		b.CtxData(MethodFatal, dctx)
-	}
-
-	b.errorData.Log(pkgconfig.ZeroLogger.WithLevel(zerolog.FatalLevel))
-
-	b.errorData.CallListener(MethodFatal)
+	b.CallListener(MethodFatal)
 
 	os.Exit(1)
 }
@@ -496,6 +407,10 @@ func (b *Builder) Fatal(ctxs ...context.Context) {
 // ----------------------------------------------------------------------------
 
 func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {
-	b.errorData.Meta.add(key, mdtype, val)
+	b.bmerror.Meta.add(key, mdtype, val)
 	return b
 }
+
+func (b *Builder) toBMError() BMError {
+	return b.bmerror.ToBMError()
+}

exerr/constructor.go

@@ -1,274 +0,0 @@
-package exerr
-
-import (
-	"encoding/json"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"reflect"
-	"time"
-)
-
-var reflectTypeStr = reflect.TypeOf("")
-
-func FromError(err error) *ExErr {
-
-	if err == nil {
-		// prevent NPE if we call FromError with err==nil
-		return &ExErr{
-			UniqueID:       newID(),
-			Category:       CatForeign,
-			Type:           TypeInternal,
-			Severity:       SevErr,
-			Timestamp:      time.Time{},
-			StatusCode:     nil,
-			Message:        "",
-			WrappedErrType: "nil",
-			WrappedErr:     err,
-			Caller:         "",
-			OriginalError:  nil,
-			Meta:           make(MetaMap),
-			Extra:          make(map[string]any),
-		}
-	}
-
-	//goland:noinspection GoTypeAssertionOnErrors
-	if verr, ok := err.(*ExErr); ok {
-		// A simple ExErr
-		return verr
-	}
-
-	//goland:noinspection GoTypeAssertionOnErrors
-	if verr, ok := err.(langext.PanicWrappedErr); ok {
-		return &ExErr{
-			UniqueID:       newID(),
-			Category:       CatForeign,
-			Type:           TypePanic,
-			Severity:       SevErr,
-			Timestamp:      time.Time{},
-			StatusCode:     nil,
-			Message:        "A panic occured",
-			WrappedErrType: fmt.Sprintf("%T", verr),
-			WrappedErr:     err,
-			Caller:         "",
-			OriginalError:  nil,
-			Meta: MetaMap{
-				"panic_object": {DataType: MDTString, Value: fmt.Sprintf("%+v", verr.RecoveredObj())},
-				"panic_type":   {DataType: MDTString, Value: fmt.Sprintf("%T", verr.RecoveredObj())},
-				"stack":        {DataType: MDTString, Value: verr.Stack},
-			},
-			Extra: make(map[string]any),
-		}
-	}
-
-	//goland:noinspection GoTypeAssertionOnErrors
-	if verr, ok := err.(*langext.PanicWrappedErr); ok && verr != nil {
-		return &ExErr{
-			UniqueID:       newID(),
-			Category:       CatForeign,
-			Type:           TypePanic,
-			Severity:       SevErr,
-			Timestamp:      time.Time{},
-			StatusCode:     nil,
-			Message:        "A panic occured",
-			WrappedErrType: fmt.Sprintf("%T", verr),
-			WrappedErr:     err,
-			Caller:         "",
-			OriginalError:  nil,
-			Meta: MetaMap{
-				"panic_object": {DataType: MDTString, Value: fmt.Sprintf("%+v", verr.RecoveredObj())},
-				"panic_type":   {DataType: MDTString, Value: fmt.Sprintf("%T", verr.RecoveredObj())},
-				"stack":        {DataType: MDTString, Value: verr.Stack},
-			},
-			Extra: make(map[string]any),
-		}
-	}
-
-	// A foreign error (eg a MongoDB exception)
-	return &ExErr{
-		UniqueID:       newID(),
-		Category:       CatForeign,
-		Type:           TypeInternal,
-		Severity:       SevErr,
-		Timestamp:      time.Time{},
-		StatusCode:     nil,
-		Message:        err.Error(),
-		WrappedErrType: fmt.Sprintf("%T", err),
-		WrappedErr:     err,
-		Caller:         "",
-		OriginalError:  nil,
-		Meta:           getForeignMeta(err),
-		Extra:          make(map[string]any),
-	}
-}
-
-func newExErr(cat ErrorCategory, errtype ErrorType, msg string) *ExErr {
-	return &ExErr{
-		UniqueID:       newID(),
-		Category:       cat,
-		Type:           errtype,
-		Severity:       SevErr,
-		Timestamp:      time.Now(),
-		StatusCode:     nil,
-		Message:        msg,
-		WrappedErrType: "",
-		WrappedErr:     nil,
-		Caller:         callername(2),
-		OriginalError:  nil,
-		Meta:           make(map[string]MetaValue),
-		Extra:          make(map[string]any),
-	}
-}
-
-func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExErr {
-	return &ExErr{
-		UniqueID:       newID(),
-		Category:       cat,
-		Type:           TypeWrap,
-		Severity:       e.Severity,
-		Timestamp:      time.Now(),
-		StatusCode:     e.StatusCode,
-		Message:        msg,
-		WrappedErrType: "",
-		WrappedErr:     nil,
-		Caller:         callername(1 + stacktraceskip),
-		OriginalError:  e,
-		Meta:           make(map[string]MetaValue),
-		Extra:          langext.CopyMap(langext.ForceMap(e.Extra)),
-	}
-}
-
-func getForeignMeta(err error) (mm MetaMap) {
-	mm = make(map[string]MetaValue)
-
-	defer func() {
-		if panicerr := recover(); panicerr != nil {
-			New(TypePanic, "Panic while trying to get foreign meta").
-				Str("source", err.Error()).
-				Interface("panic-object", panicerr).
-				Stack().
-				Print()
-		}
-	}()
-
-	rval := reflect.ValueOf(err)
-	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Ptr {
-		rval = reflect.ValueOf(err).Elem()
-	}
-
-	mm.add("foreign.errortype", MDTString, rval.Type().String())
-
-	for k, v := range addMetaPrefix("foreign", getReflectedMetaValues(err, 8)) {
-		mm[k] = v
-	}
-
-	return mm
-}
-
-func getReflectedMetaValues(value interface{}, remainingDepth int) map[string]MetaValue {
-
-	if remainingDepth <= 0 {
-		return map[string]MetaValue{}
-	}
-
-	if langext.IsNil(value) {
-		return map[string]MetaValue{"": {DataType: MDTNil, Value: nil}}
-	}
-
-	rval := reflect.ValueOf(value)
-
-	if rval.Type().Kind() == reflect.Ptr {
-
-		if rval.IsNil() {
-			return map[string]MetaValue{"*": {DataType: MDTNil, Value: nil}}
-		}
-
-		elem := rval.Elem()
-
-		return addMetaPrefix("*", getReflectedMetaValues(elem.Interface(), remainingDepth-1))
-	}
-
-	if !rval.CanInterface() {
-		return map[string]MetaValue{"": {DataType: MDTString, Value: "<<no-interface>>"}}
-	}
-
-	raw := rval.Interface()
-
-	switch ifraw := raw.(type) {
-	case time.Time:
-		return map[string]MetaValue{"": {DataType: MDTTime, Value: ifraw}}
-	case time.Duration:
-		return map[string]MetaValue{"": {DataType: MDTDuration, Value: ifraw}}
-	case int:
-		return map[string]MetaValue{"": {DataType: MDTInt, Value: ifraw}}
-	case int8:
-		return map[string]MetaValue{"": {DataType: MDTInt8, Value: ifraw}}
-	case int16:
-		return map[string]MetaValue{"": {DataType: MDTInt16, Value: ifraw}}
-	case int32:
-		return map[string]MetaValue{"": {DataType: MDTInt32, Value: ifraw}}
-	case int64:
-		return map[string]MetaValue{"": {DataType: MDTInt64, Value: ifraw}}
-	case string:
-		return map[string]MetaValue{"": {DataType: MDTString, Value: ifraw}}
-	case bool:
-		return map[string]MetaValue{"": {DataType: MDTBool, Value: ifraw}}
-	case []byte:
-		return map[string]MetaValue{"": {DataType: MDTBytes, Value: ifraw}}
-	case float32:
-		return map[string]MetaValue{"": {DataType: MDTFloat32, Value: ifraw}}
-	case float64:
-		return map[string]MetaValue{"": {DataType: MDTFloat64, Value: ifraw}}
-	case []int:
-		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
-	case []int32:
-		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
-	case primitive.ObjectID:
-		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
-	case []string:
-		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
-	}
-
-	if rval.Type().Kind() == reflect.Struct {
-		m := make(map[string]MetaValue)
-		for i := 0; i < rval.NumField(); i++ {
-			fieldtype := rval.Type().Field(i)
-
-			fieldname := fieldtype.Name
-
-			if fieldtype.IsExported() {
-				for k, v := range addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)) {
-					m[k] = v
-				}
-			}
-		}
-		return m
-	}
-
-	if rval.Type().ConvertibleTo(reflectTypeStr) {
-		return map[string]MetaValue{"": {DataType: MDTString, Value: rval.Convert(reflectTypeStr).String()}}
-	}
-
-	jsonval, err := json.Marshal(value)
-	if err != nil {
-		return map[string]MetaValue{"": {DataType: MDTString, Value: fmt.Sprintf("Failed to Marshal %T:\n%+v", value, value)}}
-	}
-
-	return map[string]MetaValue{"": {DataType: MDTString, Value: string(jsonval)}}
-}
-
-func addMetaPrefix(prefix string, m map[string]MetaValue) map[string]MetaValue {
-	if len(m) == 1 {
-		for k, v := range m {
-			if k == "" {
-				return map[string]MetaValue{prefix: v}
-			}
-		}
-	}
-
-	r := make(map[string]MetaValue, len(m))
-	for k, v := range m {
-		r[prefix+"."+k] = v
-	}
-	return r
-}

exerr/data.go

@@ -1,18 +1,32 @@
 package exerr
 
-type Method string
+type ErrorCategory struct{ Category string }
 
-const (
-	MethodOutput Method = "OUTPUT"
-	MethodPrint  Method = "PRINT"
-	MethodBuild  Method = "BUILD"
-	MethodFatal  Method = "FATAL"
+var (
+	CatWrap    = ErrorCategory{"Wrap"}    // The error is simply wrapping another error (e.g. when a grpc call returns an error)
+	CatSystem  = ErrorCategory{"System"}  // An internal system error (e.g. connection to db failed)
+	CatUser    = ErrorCategory{"User"}    // The user (the API caller) did something wrong (e.g. he has no permissions to do this)
+	CatForeign = ErrorCategory{"Foreign"} // A foreign error that some component threw (e.g. an unknown mongodb error), happens if we call Wrap(..) on an non-bmerror value
 )
 
-type LogPrintLevel string
+var AllCategories = []ErrorCategory{CatWrap, CatSystem, CatUser, CatForeign}
 
-const (
-	LogPrintFull     LogPrintLevel = "Full"
-	LogPrintOverview LogPrintLevel = "Overview"
-	LogPrintShort    LogPrintLevel = "Short"
+type ErrorSeverity struct{ Severity string }
+
+var (
+	SevTrace = ErrorSeverity{"Trace"}
+	SevDebug = ErrorSeverity{"Debug"}
+	SevInfo  = ErrorSeverity{"Info"}
+	SevWarn  = ErrorSeverity{"Warn"}
+	SevErr   = ErrorSeverity{"Err"}
+	SevFatal = ErrorSeverity{"Fatal"}
+)
+
+var AllSeverities = []ErrorSeverity{SevTrace, SevDebug, SevInfo, SevWarn, SevErr, SevFatal}
+
+type ErrorType struct{ Key string }
+
+var (
+	TypeInternal = ErrorType{"Internal"}
+	// other values come from pkgconfig
 )

exerr/dataCategory.go

@@ -1,89 +0,0 @@
-package exerr
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
-)
-
-type ErrorCategory struct{ Category string }
-
-var (
-	CatWrap    = ErrorCategory{"Wrap"}    // The error is simply wrapping another error (e.g. when a grpc call returns an error)
-	CatSystem  = ErrorCategory{"System"}  // An internal system error (e.g. connection to db failed)
-	CatUser    = ErrorCategory{"User"}    // The user (the API caller) did something wrong (e.g. he has no permissions to do this)
-	CatForeign = ErrorCategory{"Foreign"} // A foreign error that some component threw (e.g. an unknown mongodb error), happens if we call Wrap(..) on an non-bmerror value
-)
-
-func (e *ErrorCategory) UnmarshalJSON(bytes []byte) error {
-	return json.Unmarshal(bytes, &e.Category)
-}
-
-func (e ErrorCategory) MarshalJSON() ([]byte, error) {
-	return json.Marshal(e.Category)
-}
-
-func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
-		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
-		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
-		// https://stackoverflow.com/questions/75167597
-		// https://jira.mongodb.org/browse/GODRIVER-2252
-		*e = ErrorCategory{}
-		return nil
-	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
-	}
-	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
-	if err != nil {
-		return err
-	}
-	*e = ErrorCategory{tt}
-	return nil
-}
-
-func (e ErrorCategory) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Category)
-}
-
-func (e ErrorCategory) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
-}
-
-//goland:noinspection GoUnusedGlobalVariable
-var AllCategories = []ErrorCategory{CatWrap, CatSystem, CatUser, CatForeign}

exerr/dataSeverity.go

@@ -1,91 +0,0 @@
-package exerr
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
-)
-
-type ErrorSeverity struct{ Severity string }
-
-var (
-	SevTrace = ErrorSeverity{"Trace"}
-	SevDebug = ErrorSeverity{"Debug"}
-	SevInfo  = ErrorSeverity{"Info"}
-	SevWarn  = ErrorSeverity{"Warn"}
-	SevErr   = ErrorSeverity{"Err"}
-	SevFatal = ErrorSeverity{"Fatal"}
-)
-
-func (e *ErrorSeverity) UnmarshalJSON(bytes []byte) error {
-	return json.Unmarshal(bytes, &e.Severity)
-}
-
-func (e ErrorSeverity) MarshalJSON() ([]byte, error) {
-	return json.Marshal(e.Severity)
-}
-
-func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
-		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
-		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
-		// https://stackoverflow.com/questions/75167597
-		// https://jira.mongodb.org/browse/GODRIVER-2252
-		*e = ErrorSeverity{}
-		return nil
-	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
-	}
-	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
-	if err != nil {
-		return err
-	}
-	*e = ErrorSeverity{tt}
-	return nil
-}
-
-func (e ErrorSeverity) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Severity)
-}
-
-func (e ErrorSeverity) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
-}
-
-//goland:noinspection GoUnusedGlobalVariable
-var AllSeverities = []ErrorSeverity{SevTrace, SevDebug, SevInfo, SevWarn, SevErr, SevFatal}

exerr/dataType.go

@@ -1,156 +0,0 @@
-package exerr
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"reflect"
-)
-
-type ErrorType struct {
-	Key               string
-	DefaultStatusCode *int
-}
-
-//goland:noinspection GoUnusedGlobalVariable
-var (
-	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
-	TypePanic          = NewType("PANIC", langext.Ptr(500))
-	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
-	TypeAssert         = NewType("ASSERT", langext.Ptr(500))
-
-	TypeMongoQuery        = NewType("MONGO_QUERY", langext.Ptr(500))
-	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500))
-	TypeMongoFilter       = NewType("MONGO_FILTER", langext.Ptr(500))
-	TypeMongoReflection   = NewType("MONGO_REFLECTION", langext.Ptr(500))
-	TypeMongoInvalidOpt   = NewType("MONGO_INVALIDOPT", langext.Ptr(500))
-
-	TypeSQLQuery  = NewType("SQL_QUERY", langext.Ptr(500))
-	TypeSQLBuild  = NewType("SQL_BUILD", langext.Ptr(500))
-	TypeSQLDecode = NewType("SQL_DECODE", langext.Ptr(500))
-
-	TypeWrap = NewType("Wrap", nil)
-
-	TypeBindFailURI      = NewType("BINDFAIL_URI", langext.Ptr(400))
-	TypeBindFailQuery    = NewType("BINDFAIL_QUERY", langext.Ptr(400))
-	TypeBindFailJSON     = NewType("BINDFAIL_JSON", langext.Ptr(400))
-	TypeBindFailFormData = NewType("BINDFAIL_FORMDATA", langext.Ptr(400))
-	TypeBindFailHeader   = NewType("BINDFAIL_HEADER", langext.Ptr(400))
-
-	TypeMarshalEntityID = NewType("MARSHAL_ENTITY_ID", langext.Ptr(400))
-	TypeInvalidCSID     = NewType("INVALID_CSID", langext.Ptr(400))
-
-	TypeGoogleStatuscode = NewType("GOOGLE_STATUSCODE", langext.Ptr(400))
-	TypeGoogleResponse   = NewType("GOOGLE_RESPONSE", langext.Ptr(400))
-
-	TypeUnauthorized = NewType("UNAUTHORIZED", langext.Ptr(401))
-	TypeAuthFailed   = NewType("AUTH_FAILED", langext.Ptr(401))
-
-	TypeInvalidImage    = NewType("IMAGEEXT_INVALID_IMAGE", langext.Ptr(400))
-	TypeInvalidMimeType = NewType("IMAGEEXT_INVALID_MIMETYPE", langext.Ptr(400))
-
-	// other values come from the downstream application that uses goext
-)
-
-func (e *ErrorType) UnmarshalJSON(bytes []byte) error {
-	var k string
-	err := json.Unmarshal(bytes, &k)
-	if err != nil {
-		return err
-	}
-
-	if d, ok := registeredTypes.Get(k); ok {
-		*e = d
-		return nil
-	} else {
-		*e = ErrorType{k, nil}
-		return nil
-	}
-}
-
-func (e ErrorType) MarshalJSON() ([]byte, error) {
-	return json.Marshal(e.Key)
-}
-
-func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
-	if bt == bson.TypeNull {
-		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
-		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
-		// https://stackoverflow.com/questions/75167597
-		// https://jira.mongodb.org/browse/GODRIVER-2252
-		*e = ErrorType{}
-		return nil
-	}
-	if bt != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
-	}
-	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
-	if err != nil {
-		return err
-	}
-
-	if d, ok := registeredTypes.Get(tt); ok {
-		*e = d
-		return nil
-	} else {
-		*e = ErrorType{tt, nil}
-		return nil
-	}
-}
-
-func (e ErrorType) MarshalBSONValue() (bsontype.Type, []byte, error) {
-	return bson.MarshalValue(e.Key)
-}
-
-func (e ErrorType) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Ptr && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Ptr {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
-}
-
-var registeredTypes = dataext.SyncMap[string, ErrorType]{}
-
-func NewType(key string, defStatusCode *int) ErrorType {
-	et := ErrorType{key, defStatusCode}
-
-	registeredTypes.Set(key, et)
-
-	return et
-}
-
-func ListRegisteredTypes() []ErrorType {
-	return registeredTypes.GetAllValues()
-}

exerr/data_test.go

@@ -1,153 +0,0 @@
-package exerr
-
-import (
-	"context"
-	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"testing"
-	"time"
-)
-
-func TestJSONMarshalErrorCategory(t *testing.T) {
-
-	c1 := CatSystem
-
-	jsonbin := tst.Must(json.Marshal(c1))(t)
-
-	var c2 ErrorCategory
-	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
-
-	tst.AssertEqual(t, c1, c2)
-
-	tst.AssertEqual(t, string(jsonbin), "\"System\"")
-}
-
-func TestJSONMarshalErrorSeverity(t *testing.T) {
-
-	c1 := SevErr
-
-	jsonbin := tst.Must(json.Marshal(c1))(t)
-
-	var c2 ErrorSeverity
-	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
-
-	tst.AssertEqual(t, c1, c2)
-
-	tst.AssertEqual(t, string(jsonbin), "\"Err\"")
-}
-
-func TestJSONMarshalErrorType(t *testing.T) {
-
-	c1 := TypeNotImplemented
-
-	jsonbin := tst.Must(json.Marshal(c1))(t)
-
-	var c2 ErrorType
-	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
-
-	tst.AssertEqual(t, c1, c2)
-
-	tst.AssertEqual(t, string(jsonbin), "\"NOT_IMPLEMENTED\"")
-}
-
-func TestBSONMarshalErrorCategory(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
-	defer cancel()
-
-	client, err := mongo.Connect(ctx)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-	err = client.Ping(ctx, nil)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-
-	primimd := primitive.NewObjectID()
-
-	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": CatSystem})
-	tst.AssertNoErr(t, err)
-
-	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
-
-	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorCategory      `bson:"val"`
-	}
-
-	err = cursor.Decode(&c1)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertEqual(t, c1.Val, CatSystem)
-}
-
-func TestBSONMarshalErrorSeverity(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
-	defer cancel()
-
-	client, err := mongo.Connect(ctx)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-	err = client.Ping(ctx, nil)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-
-	primimd := primitive.NewObjectID()
-
-	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": SevErr})
-	tst.AssertNoErr(t, err)
-
-	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
-
-	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorSeverity      `bson:"val"`
-	}
-
-	err = cursor.Decode(&c1)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertEqual(t, c1.Val, SevErr)
-}
-
-func TestBSONMarshalErrorType(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
-	defer cancel()
-
-	client, err := mongo.Connect(ctx)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-	err = client.Ping(ctx, nil)
-	if err != nil {
-		t.Skip("Skip test - no local mongo found")
-		return
-	}
-
-	primimd := primitive.NewObjectID()
-
-	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": TypeNotImplemented})
-	tst.AssertNoErr(t, err)
-
-	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
-
-	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
-		Val ErrorType          `bson:"val"`
-	}
-
-	err = cursor.Decode(&c1)
-	tst.AssertNoErr(t, err)
-
-	tst.AssertEqual(t, c1.Val, TypeNotImplemented)
-}

exerr/defaults.go

@@ -0,0 +1 @@
+package exerr

exerr/errinit.go

@@ -1,62 +1,23 @@
 package exerr
 
-import (
-	"context"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"github.com/rs/zerolog"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"net/http"
-	"os"
-)
-
 type ErrorPackageConfig struct {
-	ZeroLogErrTraces       bool                                                                     // autom print zerolog logs on .Build()  (for SevErr and SevFatal)
-	ZeroLogAllTraces       bool                                                                     // autom print zerolog logs on .Build()  (for all Severities)
+	ZeroLogTraces   bool        // autom print zerolog logs on CreateError
 	RecursiveErrors bool        // errors contains their Origin-Error
-	ExtendedGinOutput      bool                                                                     // Log extended data (trace, meta, ...) to gin in err.Output()
-	IncludeMetaInGinOutput bool                                                                     // Log meta fields ( from e.g. `.Str(key, val).Build()` ) to gin in err.Output()
-	ExtendGinOutput        func(err *ExErr, json map[string]any)                                    // (Optionally) extend the gin output with more fields
-	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)                         // (Optionally) extend the gin `__data` output with more fields
-	DisableErrorWrapping   bool                                                                     // Disables the exerr.Wrap()...Build() function - will always return the original error
-	ZeroLogErrGinOutput    bool                                                                     // autom print zerolog logs on ginext.Error() / .Output(gin)  (for SevErr and SevFatal)
-	ZeroLogAllGinOutput    bool                                                                     // autom print zerolog logs on ginext.Error() / .Output(gin)  (for all Severities)
-	ExtendGinMeta          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) // (Optionally) extend the final error meta values with additional data from the gin context (a few are automatically added, here more can be included)
-	ExtendContextMeta      func(b *Builder, method Method, dctx context.Context)                    // (Optionally) extend the final error meta values with additional data from the context (a few are automatically added, here more can be included)
-	ZeroLogger             zerolog.Logger                                                           // The logger used to print exerr log messages
+	Types           []ErrorType // all available error-types
 }
 
 type ErrorPackageConfigInit struct {
-	ZeroLogErrTraces       *bool
-	ZeroLogAllTraces       *bool
-	RecursiveErrors        *bool
-	ExtendedGinOutput      *bool
-	IncludeMetaInGinOutput *bool
-	ExtendGinOutput        func(err *ExErr, json map[string]any)
-	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)
-	DisableErrorWrapping   *bool
-	ZeroLogErrGinOutput    *bool
-	ZeroLogAllGinOutput    *bool
-	ExtendGinMeta          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request)
-	ExtendContextMeta      func(b *Builder, method Method, dctx context.Context)
-	ZeroLogger             *zerolog.Logger
+	LogTraces       bool
+	RecursiveErrors bool
+	InitTypes       func(_ func(_ string) ErrorType)
 }
 
 var initialized = false
 
 var pkgconfig = ErrorPackageConfig{
-	ZeroLogErrTraces:       true,
-	ZeroLogAllTraces:       false,
+	ZeroLogTraces:   true,
 	RecursiveErrors: true,
-	ExtendedGinOutput:      false,
-	IncludeMetaInGinOutput: true,
-	ExtendGinOutput:        func(err *ExErr, json map[string]any) {},
-	ExtendGinDataOutput:    func(err *ExErr, depth int, json map[string]any) {},
-	DisableErrorWrapping:   false,
-	ZeroLogErrGinOutput:    true,
-	ZeroLogAllGinOutput:    false,
-	ExtendGinMeta:          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) {},
-	ExtendContextMeta:      func(b *Builder, method Method, dctx context.Context) {},
+	Types:           []ErrorType{TypeInternal},
 }
 
 // Init initializes the exerr packages
@@ -67,72 +28,23 @@ func Init(cfg ErrorPackageConfigInit) {
 		panic("Cannot re-init error package")
 	}
 
-	ego := func(err *ExErr, json map[string]any) {}
-	egdo := func(err *ExErr, depth int, json map[string]any) {}
-	egm := func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) {}
-	egcm := func(b *Builder, method Method, dctx context.Context) {}
+	types := pkgconfig.Types
 
-	if cfg.ExtendGinOutput != nil {
-		ego = cfg.ExtendGinOutput
-	}
-	if cfg.ExtendGinDataOutput != nil {
-		egdo = cfg.ExtendGinDataOutput
-	}
-	if cfg.ExtendGinMeta != nil {
-		egm = cfg.ExtendGinMeta
-	}
-	if cfg.ExtendContextMeta != nil {
-		egcm = cfg.ExtendContextMeta
+	fnAddType := func(v string) ErrorType {
+		et := ErrorType{v}
+		types = append(types, et)
+		return et
 	}
 
-	var logger zerolog.Logger
-	if cfg.ZeroLogger != nil {
-		logger = *cfg.ZeroLogger
-	} else {
-		logger = newDefaultLogger()
+	if cfg.InitTypes != nil {
+		cfg.InitTypes(fnAddType)
 	}
 
 	pkgconfig = ErrorPackageConfig{
-		ZeroLogErrTraces:       langext.Coalesce(cfg.ZeroLogErrTraces, pkgconfig.ZeroLogErrTraces),
-		ZeroLogAllTraces:       langext.Coalesce(cfg.ZeroLogAllTraces, pkgconfig.ZeroLogAllTraces),
-		RecursiveErrors:        langext.Coalesce(cfg.RecursiveErrors, pkgconfig.RecursiveErrors),
-		ExtendedGinOutput:      langext.Coalesce(cfg.ExtendedGinOutput, pkgconfig.ExtendedGinOutput),
-		IncludeMetaInGinOutput: langext.Coalesce(cfg.IncludeMetaInGinOutput, pkgconfig.IncludeMetaInGinOutput),
-		ExtendGinOutput:        ego,
-		ExtendGinDataOutput:    egdo,
-		DisableErrorWrapping:   langext.Coalesce(cfg.DisableErrorWrapping, pkgconfig.DisableErrorWrapping),
-		ZeroLogAllGinOutput:    langext.Coalesce(cfg.ZeroLogAllGinOutput, pkgconfig.ZeroLogAllGinOutput),
-		ZeroLogErrGinOutput:    langext.Coalesce(cfg.ZeroLogErrGinOutput, pkgconfig.ZeroLogErrGinOutput),
-		ExtendGinMeta:          egm,
-		ExtendContextMeta:      egcm,
-		ZeroLogger:             logger,
+		ZeroLogTraces:   cfg.LogTraces,
+		RecursiveErrors: cfg.RecursiveErrors,
+		Types:           types,
 	}
 
 	initialized = true
 }
-
-func newDefaultLogger() zerolog.Logger {
-	cw := zerolog.ConsoleWriter{
-		Out:        os.Stdout,
-		TimeFormat: "2006-01-02 15:04:05 Z07:00",
-	}
-
-	multi := zerolog.MultiLevelWriter(cw)
-
-	return zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(4).Logger()
-}
-
-func Initialized() bool {
-	return initialized
-}
-
-func warnOnPkgConfigNotInitialized() {
-	if !initialized {
-		fmt.Printf("\n")
-		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
-		fmt.Printf("%s\n", "[WARNING] exerr package used without initializiation")
-		fmt.Printf("%s\n", "          call exerr.Init() in your main() function")
-		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
-		fmt.Printf("\n")
-	}
-}

exerr/exerr.go

@@ -1,12 +1,6 @@
 package exerr
 
 import (
-	"fmt"
-	"github.com/rs/xid"
-	"github.com/rs/zerolog"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"reflect"
-	"strings"
 	"time"
 )
 
@@ -18,419 +12,22 @@ type ExErr struct {
 	Severity  ErrorSeverity `json:"severity"`
 	Type      ErrorType     `json:"type"`
 
-	StatusCode *int `json:"statusCode"`
-
 	Message string `json:"message"`
-	WrappedErrType string `json:"wrappedErrType"`
-	WrappedErr     any    `json:"-"`
 	Caller  string `json:"caller"`
 
-	OriginalError *ExErr `json:"originalError"`
+	OriginalError *ExErr
 
-	Extra map[string]any `json:"extra"`
 	Meta MetaMap `json:"meta"`
 }
 
-func (ee *ExErr) Error() string {
-	return ee.RecursiveMessage()
+func (ee ExErr) Error() string {
+
 }
 
-// Unwrap must be implemented so that some error.XXX methods work
-func (ee *ExErr) Unwrap() error {
-	if ee.OriginalError == nil {
+func (ee ExErr) Unwrap() error {
 
-		if ee.WrappedErr != nil {
-			if werr, ok := ee.WrappedErr.(error); ok {
-				return werr
-			}
-		}
-
-		return nil // this is neccessary - otherwise we return a wrapped nil and the `x == nil` comparison fails (= panic in errors.Is and other failures)
-	}
-	return ee.OriginalError
 }
 
-// Is must be implemented so that error.Is(x) works
-func (ee *ExErr) Is(e error) bool {
-	return IsFrom(ee, e)
-}
-
-// As must be implemented so that error.As(x) works
-//
-//goland:noinspection GoTypeAssertionOnErrors
-func (ee *ExErr) As(target any) bool {
-	if dstErr, ok := target.(*ExErr); ok {
-
-		if dst0, ok := ee.contains(dstErr); ok {
-			dstErr = dst0
-			return true
-		} else {
-			return false
-		}
-
-	} else {
-
-		val := reflect.ValueOf(target)
-
-		typStr := val.Type().Elem().String()
-
-		for curr := ee; curr != nil; curr = curr.OriginalError {
-			if curr.Category == CatForeign && curr.WrappedErrType == typStr && curr.WrappedErr != nil {
-				val.Elem().Set(reflect.ValueOf(curr.WrappedErr))
-				return true
-			}
-		}
-
-		return false
-	}
-}
-
-func (ee *ExErr) Log(evt *zerolog.Event) {
-	evt.Msg(ee.FormatLog(LogPrintFull))
-}
-
-func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
-
-	// [LogPrintShort]
-	//
-	// - Only print message and type
-	// - Used e.g. for logging to the console when Build is called
-	// - also used in Print() if level == Warn/Info
-	//
-	// [LogPrintOverview]
-	//
-	// - print message, extra and errortrace
-	//
-	// [LogPrintFull]
-	//
-	// - print full error, with meta and extra, and trace, etc
-	// - Used in Output() and Print()
-	//
-
-	if lvl == LogPrintShort {
-
-		msg := ee.Message
-		if msg == "" {
-			msg = ee.RecursiveMessage()
-		}
-		if ee.OriginalError != nil && ee.OriginalError.Category == CatForeign {
-			msg = msg + " (" + strings.ReplaceAll(ee.OriginalError.Message, "\n", " ") + ")"
-		}
-
-		if ee.Type != TypeWrap {
-			return "[" + ee.Type.Key + "] " + msg
-		} else {
-			return msg
-		}
-
-	} else if lvl == LogPrintOverview {
-
-		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
-
-		for exk, exv := range ee.Extra {
-			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
-		}
-
-		indent := ""
-		for curr := ee; curr != nil; curr = curr.OriginalError {
-			indent += "  "
-
-			str += indent
-			str += "-> "
-			strmsg := strings.Trim(curr.Message, " \r\n\t")
-			if lbidx := strings.Index(curr.Message, "\n"); lbidx >= 0 {
-				strmsg = strmsg[0:lbidx]
-			}
-			strmsg = langext.StrLimit(strmsg, 61, "...")
-			str += strmsg
-			str += "\n"
-
-		}
-		return str
-
-	} else if lvl == LogPrintFull {
-
-		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
-
-		for exk, exv := range ee.Extra {
-			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
-		}
-
-		indent := ""
-		for curr := ee; curr != nil; curr = curr.OriginalError {
-			indent += "  "
-
-			etype := curr.Type.Key
-			if curr.Type == TypeWrap {
-				etype = "~"
-			}
-
-			str += indent
-			str += "-> ["
-			str += etype
-			if curr.Category == CatForeign {
-				str += "|Foreign"
-			}
-			str += "] "
-			str += strings.ReplaceAll(curr.Message, "\n", " ")
-			if curr.Caller != "" {
-				str += " (@ "
-				str += curr.Caller
-				str += ")"
-			}
-			str += "\n"
-
-			if curr.Meta.Any() {
-				meta := indent + "   {" + curr.Meta.FormatOneLine(240) + "}"
-				if len(meta) < 200 {
-					str += meta
-					str += "\n"
-				} else {
-					str += curr.Meta.FormatMultiLine(indent+"   ", "  ", 1024)
-					str += "\n"
-				}
-			}
-		}
-		return str
-
-	} else {
-
-		return "[?[" + ee.UniqueID + "]?]"
-
-	}
-}
-
-func (ee *ExErr) ShortLog(evt *zerolog.Event) {
-	ee.Meta.Apply(evt, langext.Ptr(240)).Msg(ee.FormatLog(LogPrintShort))
-}
-
-// RecursiveMessage returns the message to show
-// = first error (top-down) that is not foreign/empty
-// = lowest level error (that is not empty)
-// = fallback to self.message
-func (ee *ExErr) RecursiveMessage() string {
-
-	// ==== [1] ==== first error (top-down) that is not wrapping/foreign/empty
-
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.Message != "" && curr.Category != CatForeign {
-			return curr.Message
-		}
-	}
-
-	// ==== [2] ==== lowest level error (that is not empty)
-
-	deepestMsg := ""
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.Message != "" {
-			deepestMsg = curr.Message
-		}
-	}
-	if deepestMsg != "" {
-		return deepestMsg
-	}
-
-	// ==== [3] ==== fallback to self.message
-
-	return ee.Message
-}
-
-// RecursiveType returns the statuscode to use
-// = first error (top-down) that is not wrapping/empty
-func (ee *ExErr) RecursiveType() ErrorType {
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.Type != TypeWrap {
-			return curr.Type
-		}
-
-	}
-
-	// fallback to self
-	return ee.Type
-}
-
-// RecursiveStatuscode returns the HTTP Statuscode to use
-// = first error (top-down) that has a statuscode set
-func (ee *ExErr) RecursiveStatuscode() *int {
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.StatusCode != nil {
-			return langext.Ptr(*curr.StatusCode)
-		}
-	}
-
-	return nil
-}
-
-// RecursiveCategory returns the ErrorCategory to use
-// = first error (top-down) that has a statuscode set
-func (ee *ExErr) RecursiveCategory() ErrorCategory {
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.Category != CatWrap {
-			return curr.Category
-		}
-	}
-
-	// fallback to <empty>
-	return ee.Category
-}
-
-// RecursiveMeta searches (top-down) for teh first error that has a meta value with teh specified key
-// and returns its value (or nil)
-func (ee *ExErr) RecursiveMeta(key string) *MetaValue {
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if metaval, ok := curr.Meta[key]; ok {
-			return langext.Ptr(metaval)
-		}
-	}
-
-	return nil
-}
-
-// Depth returns the depth of recursively contained errors
-func (ee *ExErr) Depth() int {
-	if ee.OriginalError == nil {
-		return 1
-	} else {
-		return ee.OriginalError.Depth() + 1
-	}
-}
-
-// GetMeta returns the meta value with the specified key
-// this method recurses through all wrapped errors and returns the first matching meta value
-func (ee *ExErr) GetMeta(key string) (any, bool) {
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if v, ok := curr.Meta[key]; ok {
-			return v.Value, true
-		}
-	}
-
-	return nil, false
-}
-
-// GetMetaString functions the same as GetMeta, but returns false if the type does not match
-func (ee *ExErr) GetMetaString(key string) (string, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(string); ok {
-			return v2, true
-		}
-	}
-	return "", false
-}
-
-func (ee *ExErr) GetMetaBool(key string) (bool, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(bool); ok {
-			return v2, true
-		}
-	}
-	return false, false
-}
-
-func (ee *ExErr) GetMetaInt(key string) (int, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(int); ok {
-			return v2, true
-		}
-	}
-	return 0, false
-}
-
-func (ee *ExErr) GetMetaFloat32(key string) (float32, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(float32); ok {
-			return v2, true
-		}
-	}
-	return 0, false
-}
-
-func (ee *ExErr) GetMetaFloat64(key string) (float64, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(float64); ok {
-			return v2, true
-		}
-	}
-	return 0, false
-}
-
-func (ee *ExErr) GetMetaTime(key string) (time.Time, bool) {
-	if v1, ok := ee.GetMeta(key); ok {
-		if v2, ok := v1.(time.Time); ok {
-			return v2, true
-		}
-	}
-	return time.Time{}, false
-}
-
-func (ee *ExErr) GetExtra(key string) (any, bool) {
-	if v, ok := ee.Extra[key]; ok {
-		return v, true
-	}
-
-	return nil, false
-}
-
-func (ee *ExErr) UniqueIDs() []string {
-	ids := []string{ee.UniqueID}
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		ids = append(ids, curr.UniqueID)
-	}
-	return ids
-}
-
-// contains test if the supplied error is contained in this error (anywhere in the chain)
-func (ee *ExErr) contains(original *ExErr) (*ExErr, bool) {
-	if original == nil {
-		return nil, false
-	}
-
-	if ee == original {
-		return ee, true
-	}
-
-	for curr := ee; curr != nil; curr = curr.OriginalError {
-		if curr.equalsDirectProperties(curr) {
-			return curr, true
-		}
-	}
-
-	return nil, false
-}
-
-// equalsDirectProperties tests if ee and other are equals, but only looks at primary properties (not `OriginalError` or `Meta`)
-func (ee *ExErr) equalsDirectProperties(other *ExErr) bool {
-
-	if ee.UniqueID != other.UniqueID {
-		return false
-	}
-	if ee.Timestamp != other.Timestamp {
-		return false
-	}
-	if ee.Category != other.Category {
-		return false
-	}
-	if ee.Severity != other.Severity {
-		return false
-	}
-	if ee.Type != other.Type {
-		return false
-	}
-	if ee.StatusCode != other.StatusCode {
-		return false
-	}
-	if ee.Message != other.Message {
-		return false
-	}
-	if ee.WrappedErrType != other.WrappedErrType {
-		return false
-	}
-	if ee.Caller != other.Caller {
-		return false
-	}
-
-	return true
-}
-
-func newID() string {
-	return xid.New().String()
+func (ee ExErr) Is(err error) bool {
+
 }

exerr/exerr_test.go

@@ -1,102 +0,0 @@
-package exerr
-
-import (
-	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
-	"os"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	if !Initialized() {
-		Init(ErrorPackageConfigInit{ZeroLogErrTraces: langext.PFalse, ZeroLogAllTraces: langext.PFalse})
-	}
-	os.Exit(m.Run())
-}
-
-type golangErr struct {
-	Message string
-}
-
-func (g golangErr) Error() string {
-	return g.Message
-}
-
-type golangErr2 struct {
-	Message string
-}
-
-func (g golangErr2) Error() string {
-	return g.Message
-}
-
-type simpleError struct {
-}
-
-func (g simpleError) Error() string {
-	return "Something simple went wroong"
-}
-
-type simpleError2 struct {
-}
-
-func (g simpleError2) Error() string {
-	return "Something simple went wroong"
-}
-
-func TestExErrIs1(t *testing.T) {
-	e0 := simpleError{}
-
-	wrap := Wrap(e0, "something went wrong").Str("test", "123").Build()
-
-	tst.AssertTrue(t, errors.Is(wrap, simpleError{}))
-	tst.AssertFalse(t, errors.Is(wrap, golangErr{}))
-	tst.AssertFalse(t, errors.Is(wrap, golangErr{"error1"}))
-}
-
-func TestExErrIs2(t *testing.T) {
-	e0 := golangErr{"error1"}
-
-	wrap := Wrap(e0, "something went wrong").Str("test", "123").Build()
-
-	tst.AssertTrue(t, errors.Is(wrap, e0))
-	tst.AssertTrue(t, errors.Is(wrap, golangErr{"error1"}))
-	tst.AssertFalse(t, errors.Is(wrap, golangErr{"error2"}))
-	tst.AssertFalse(t, errors.Is(wrap, simpleError{}))
-}
-
-func TestExErrAs(t *testing.T) {
-
-	e0 := golangErr{"error1"}
-
-	w0 := Wrap(e0, "something went wrong").Str("test", "123").Build()
-
-	{
-		out := golangErr{}
-		ok := errors.As(w0, &out)
-		tst.AssertTrue(t, ok)
-		tst.AssertEqual(t, out.Message, "error1")
-	}
-
-	w1 := Wrap(w0, "outher error").Build()
-
-	{
-		out := golangErr{}
-		ok := errors.As(w1, &out)
-		tst.AssertTrue(t, ok)
-		tst.AssertEqual(t, out.Message, "error1")
-	}
-
-	{
-		out := golangErr2{}
-		ok := errors.As(w1, &out)
-		tst.AssertFalse(t, ok)
-	}
-
-	{
-		out := simpleError2{}
-		ok := errors.As(w1, &out)
-		tst.AssertFalse(t, ok)
-	}
-}

exerr/foreign.go

@@ -0,0 +1,146 @@
+package exerr
+
+import (
+	"bringman.de/common/shared/langext"
+	"encoding/json"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"reflect"
+	"time"
+)
+
+var reflectTypeStr = reflect.TypeOf("")
+
+func getForeignMeta(err error) (mm MetaMap) {
+	mm = make(map[string]MetaValue)
+
+	defer func() {
+		if panicerr := recover(); panicerr != nil {
+			New(ErrPanic, "Panic while trying to get foreign meta").
+				Str("source", err.Error()).
+				Interface("panic-object", panicerr).
+				Stack().
+				Print()
+		}
+	}()
+
+	rval := reflect.ValueOf(err)
+	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Ptr {
+		rval = reflect.ValueOf(err).Elem()
+	}
+
+	mm.add("foreign.errortype", MDTString, rval.Type().String())
+
+	for k, v := range addMetaPrefix("foreign", getReflectedMetaValues(err, 8)) {
+		mm[k] = v
+	}
+
+	return mm
+}
+
+func getReflectedMetaValues(value interface{}, remainingDepth int) map[string]MetaValue {
+
+	if remainingDepth <= 0 {
+		return map[string]MetaValue{}
+	}
+
+	if langext.IsNil(value) {
+		return map[string]MetaValue{"": {DataType: MDTNil, Value: nil}}
+	}
+
+	rval := reflect.ValueOf(value)
+
+	if rval.Type().Kind() == reflect.Ptr {
+
+		if rval.IsNil() {
+			return map[string]MetaValue{"*": {DataType: MDTNil, Value: nil}}
+		}
+
+		elem := rval.Elem()
+
+		return addMetaPrefix("*", getReflectedMetaValues(elem.Interface(), remainingDepth-1))
+	}
+
+	if !rval.CanInterface() {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: "<<no-interface>>"}}
+	}
+
+	raw := rval.Interface()
+
+	switch ifraw := raw.(type) {
+	case time.Time:
+		return map[string]MetaValue{"": {DataType: MDTTime, Value: ifraw}}
+	case time.Duration:
+		return map[string]MetaValue{"": {DataType: MDTDuration, Value: ifraw}}
+	case int:
+		return map[string]MetaValue{"": {DataType: MDTInt, Value: ifraw}}
+	case int8:
+		return map[string]MetaValue{"": {DataType: MDTInt8, Value: ifraw}}
+	case int16:
+		return map[string]MetaValue{"": {DataType: MDTInt16, Value: ifraw}}
+	case int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32, Value: ifraw}}
+	case int64:
+		return map[string]MetaValue{"": {DataType: MDTInt64, Value: ifraw}}
+	case string:
+		return map[string]MetaValue{"": {DataType: MDTString, Value: ifraw}}
+	case bool:
+		return map[string]MetaValue{"": {DataType: MDTBool, Value: ifraw}}
+	case []byte:
+		return map[string]MetaValue{"": {DataType: MDTBytes, Value: ifraw}}
+	case float32:
+		return map[string]MetaValue{"": {DataType: MDTFloat32, Value: ifraw}}
+	case float64:
+		return map[string]MetaValue{"": {DataType: MDTFloat64, Value: ifraw}}
+	case []int:
+		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
+	case []int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
+	case primitive.ObjectID:
+		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
+	case []string:
+		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
+	}
+
+	if rval.Type().Kind() == reflect.Struct {
+		m := make(map[string]MetaValue)
+		for i := 0; i < rval.NumField(); i++ {
+			fieldtype := rval.Type().Field(i)
+
+			fieldname := fieldtype.Name
+
+			if fieldtype.IsExported() {
+				for k, v := range addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)) {
+					m[k] = v
+				}
+			}
+		}
+		return m
+	}
+
+	if rval.Type().ConvertibleTo(reflectTypeStr) {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: rval.Convert(reflectTypeStr).String()}}
+	}
+
+	jsonval, err := json.Marshal(value)
+	if err != nil {
+		panic(err) // gets recovered later up
+	}
+
+	return map[string]MetaValue{"": {DataType: MDTString, Value: string(jsonval)}}
+}
+
+func addMetaPrefix(prefix string, m map[string]MetaValue) map[string]MetaValue {
+	if len(m) == 1 {
+		for k, v := range m {
+			if k == "" {
+				return map[string]MetaValue{prefix: v}
+			}
+		}
+	}
+
+	r := make(map[string]MetaValue, len(m))
+	for k, v := range m {
+		r[prefix+"."+k] = v
+	}
+	return r
+}

exerr/gin.go

@@ -1,145 +0,0 @@
-package exerr
-
-import (
-	"github.com/gin-gonic/gin"
-	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"net/http"
-	"time"
-)
-
-func (ee *ExErr) toJson(depth int, applyExtendListener bool, outputMeta bool) langext.H {
-	ginJson := langext.H{}
-
-	if ee.UniqueID != "" {
-		ginJson["id"] = ee.UniqueID
-	}
-	if ee.Category != CatWrap {
-		ginJson["category"] = ee.Category.Category
-	}
-	if ee.Type != TypeWrap {
-		ginJson["type"] = ee.Type.Key
-	}
-	if ee.StatusCode != nil {
-		ginJson["statuscode"] = ee.StatusCode
-	}
-	if ee.Message != "" {
-		ginJson["message"] = ee.Message
-	}
-	if ee.Caller != "" {
-		ginJson["caller"] = ee.Caller
-	}
-	if ee.Severity != SevErr {
-		ginJson["severity"] = ee.Severity.Severity
-	}
-	if ee.Timestamp != (time.Time{}) {
-		ginJson["time"] = ee.Timestamp.Format(time.RFC3339)
-	}
-	if ee.WrappedErrType != "" {
-		ginJson["wrappedErrType"] = ee.WrappedErrType
-	}
-	if ee.OriginalError != nil {
-		ginJson["original"] = ee.OriginalError.toJson(depth+1, applyExtendListener, outputMeta)
-	}
-
-	if outputMeta {
-		metaJson := langext.H{}
-		for metaKey, metaVal := range ee.Meta {
-			metaJson[metaKey] = metaVal.rawValueForJson()
-		}
-		ginJson["meta"] = metaJson
-
-		extraJson := langext.H{}
-		for extraKey, extraVal := range ee.Extra {
-			extraJson[extraKey] = extraVal
-		}
-		ginJson["extra"] = extraJson
-	}
-
-	if applyExtendListener {
-		pkgconfig.ExtendGinDataOutput(ee, depth, ginJson)
-	}
-
-	return ginJson
-}
-
-func (ee *ExErr) ToDefaultAPIJson() (string, error) {
-
-	gjr := json.GoJsonRender{Data: ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput, pkgconfig.IncludeMetaInGinOutput), NilSafeSlices: true, NilSafeMaps: true}
-
-	r, err := gjr.RenderString()
-
-	if err != nil {
-		return "", err
-	}
-
-	return r, nil
-}
-
-// ToAPIJson converts the ExError to a json object
-// (the same object as used in the Output(gin) method)
-//
-// Parameters:
-//   - [applyExtendListener]:  if false the pkgconfig.ExtendGinOutput / pkgconfig.ExtendGinDataOutput will not be applied
-//   - [includeWrappedErrors]: if false we do not include the recursive/wrapped errors in `__data`
-//   - [includeMetaFields]:    if true  we also include meta-values (aka from `.Str(key, value).Build()`), needs includeWrappedErrors=true
-func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool, includeMetaFields bool) langext.H {
-
-	apiOutput := langext.H{
-		"errorid":   ee.UniqueID,
-		"message":   ee.RecursiveMessage(),
-		"errorcode": ee.RecursiveType().Key,
-		"category":  ee.RecursiveCategory().Category,
-	}
-
-	if includeWrappedErrors {
-		apiOutput["__data"] = ee.toJson(0, applyExtendListener, includeMetaFields)
-	}
-
-	for exkey, exval := range ee.Extra {
-
-		// ensure we do not override existing values
-		for {
-			if _, ok := apiOutput[exkey]; ok {
-				exkey = "_" + exkey
-			} else {
-				break
-			}
-		}
-
-		apiOutput[exkey] = exval
-	}
-
-	if applyExtendListener {
-		pkgconfig.ExtendGinOutput(ee, apiOutput)
-	}
-
-	return apiOutput
-}
-
-func (ee *ExErr) Output(g *gin.Context) {
-
-	warnOnPkgConfigNotInitialized()
-
-	var statuscode = http.StatusInternalServerError
-
-	var baseCat = ee.RecursiveCategory()
-	var baseType = ee.RecursiveType()
-	var baseStatuscode = ee.RecursiveStatuscode()
-
-	if baseCat == CatUser {
-		statuscode = http.StatusBadRequest
-	} else if baseCat == CatSystem {
-		statuscode = http.StatusInternalServerError
-	}
-
-	if baseStatuscode != nil {
-		statuscode = *ee.StatusCode
-	} else if baseType.DefaultStatusCode != nil {
-		statuscode = *baseType.DefaultStatusCode
-	}
-
-	ginOutput := ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput, pkgconfig.IncludeMetaInGinOutput)
-
-	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
-}

exerr/helper.go

@@ -1,126 +0,0 @@
-package exerr
-
-import "fmt"
-
-// IsType test if the supplied error is of the specified ErrorType.
-func IsType(err error, errType ErrorType) bool {
-	if err == nil {
-		return false
-	}
-
-	bmerr := FromError(err)
-	for bmerr != nil {
-		if bmerr.Type == errType {
-			return true
-		}
-		bmerr = bmerr.OriginalError
-	}
-
-	return false
-}
-
-// IsFrom test if the supplied error stems originally from original
-func IsFrom(e error, original error) bool {
-	if e == nil {
-		return false
-	}
-
-	//goland:noinspection GoDirectComparisonOfErrors
-	if e == original {
-		return true
-	}
-
-	bmerr := FromError(e)
-	for bmerr == nil {
-		return false
-	}
-
-	for curr := bmerr; curr != nil; curr = curr.OriginalError {
-		if curr.Category == CatForeign && curr.Message == original.Error() && curr.WrappedErrType == fmt.Sprintf("%T", original) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// HasSourceMessage tests if the supplied error stems originally from an error with the message msg
-func HasSourceMessage(e error, msg string) bool {
-	if e == nil {
-		return false
-	}
-
-	bmerr := FromError(e)
-	for bmerr == nil {
-		return false
-	}
-
-	for curr := bmerr; curr != nil; curr = curr.OriginalError {
-		if curr.OriginalError == nil && curr.Message == msg {
-			return true
-		}
-	}
-
-	return false
-}
-
-func MessageMatch(e error, matcher func(string) bool) bool {
-	if e == nil {
-		return false
-	}
-
-	if matcher(e.Error()) {
-		return true
-	}
-
-	bmerr := FromError(e)
-	for bmerr == nil {
-		return false
-	}
-
-	for curr := bmerr; curr != nil; curr = curr.OriginalError {
-		if matcher(curr.Message) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// OriginalError returns the lowest level error, probably the original/external error that was originally wrapped
-func OriginalError(e error) error {
-	if e == nil {
-		return nil
-	}
-
-	//goland:noinspection GoTypeAssertionOnErrors
-	bmerr, ok := e.(*ExErr)
-	for !ok {
-		return e
-	}
-
-	for bmerr.OriginalError != nil {
-		bmerr = bmerr.OriginalError
-	}
-
-	if bmerr.WrappedErr != nil {
-		if werr, ok := bmerr.WrappedErr.(error); ok {
-			return werr
-		}
-	}
-
-	return bmerr
-}
-
-func UniqueID(v error) *string {
-	if v == nil {
-		return nil
-	}
-
-	//goland:noinspection GoTypeAssertionOnErrors
-	if verr, ok := v.(*ExErr); ok {
-		return &verr.UniqueID
-	}
-
-	return nil
-}

exerr/listener.go

@@ -4,7 +4,16 @@ import (
 	"sync"
 )
 
-type Listener = func(method Method, v *ExErr)
+type Method string
+
+const (
+	MethodOutput Method = "OUTPUT"
+	MethodPrint  Method = "PRINT"
+	MethodBuild  Method = "BUILD"
+	MethodFatal  Method = "FATAL"
+)
+
+type Listener = func(method Method, v ExErr)
 
 var listenerLock = sync.Mutex{}
 var listener = make([]Listener, 0)
@@ -16,11 +25,13 @@ func RegisterListener(l Listener) {
 	listener = append(listener, l)
 }
 
-func (ee *ExErr) CallListener(m Method) {
+func (b *Builder) CallListener(m Method) {
+	valErr := b.toBMError()
+
 	listenerLock.Lock()
 	defer listenerLock.Unlock()
 
 	for _, v := range listener {
-		v(m, ee)
+		v(m, valErr)
 	}
 }

exerr/meta.go

@@ -6,19 +6,15 @@ import (
 	"errors"
 	"fmt"
 	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"math"
 	"strconv"
 	"strings"
 	"time"
 )
 
-// This is a buffed up map[string]any
-// we also save type information of the map-values
-// which allows us to deserialize them back into te correct types later
-
 type MetaMap map[string]MetaValue
 
 type metaDataType string
@@ -44,7 +40,6 @@ const (
 	MDTID          metaDataType = "ID"
 	MDTAny         metaDataType = "Interface"
 	MDTNil         metaDataType = "Nil"
-	MDTEnum        metaDataType = "Enum"
 )
 
 type MetaValue struct {
@@ -133,8 +128,6 @@ func (v MetaValue) SerializeValue() (string, error) {
 		return string(r), nil
 	case MDTNil:
 		return "", nil
-	case MDTEnum:
-		return v.Value.(EnumWrap).Serialize(), nil
 	}
 	return "", errors.New("Unknown type: " + string(v.DataType))
 }
@@ -212,41 +205,27 @@ func (v MetaValue) ShortString(lim int) string {
 		return langext.StrLimit(string(r), lim, "...")
 	case MDTNil:
 		return "<<null>>"
-	case MDTEnum:
-		return v.Value.(EnumWrap).String()
 	}
 	return "(err)"
 }
 
-func (v MetaValue) Apply(key string, evt *zerolog.Event, limitLen *int) *zerolog.Event {
+func (v MetaValue) Apply(key string, evt *zerolog.Event) *zerolog.Event {
 	switch v.DataType {
 	case MDTString:
-		if limitLen == nil {
 		return evt.Str(key, v.Value.(string))
-		} else {
-			return evt.Str(key, langext.StrLimit(v.Value.(string), *limitLen, "..."))
-		}
 	case MDTID:
 		return evt.Str(key, v.Value.(IDWrap).Value)
 	case MDTAny:
 		if v.Value.(AnyWrap).IsError {
 			return evt.Str(key, "(err)")
 		} else {
-			if limitLen == nil {
 			return evt.Str(key, v.Value.(AnyWrap).Json)
-			} else {
-				return evt.Str(key, langext.StrLimit(v.Value.(AnyWrap).Json, *limitLen, "..."))
-			}
 		}
 	case MDTStringPtr:
 		if langext.IsNil(v.Value) {
 			return evt.Str(key, "<<null>>")
 		}
-		if limitLen == nil {
 		return evt.Str(key, langext.CoalesceString(v.Value.(*string), "<<null>>"))
-		} else {
-			return evt.Str(key, langext.StrLimit(langext.CoalesceString(v.Value.(*string), "<<null>>"), *limitLen, "..."))
-		}
 	case MDTInt:
 		return evt.Int(key, v.Value.(int))
 	case MDTInt8:
@@ -288,14 +267,6 @@ func (v MetaValue) Apply(key string, evt *zerolog.Event, limitLen *int) *zerolog
 		return evt.Ints32(key, v.Value.([]int32))
 	case MDTNil:
 		return evt.Str(key, "<<null>>")
-	case MDTEnum:
-		if v.Value.(EnumWrap).IsNil {
-			return evt.Any(key, nil)
-		} else if v.Value.(EnumWrap).ValueRaw != nil {
-			return evt.Any(key, v.Value.(EnumWrap).ValueRaw)
-		} else {
-			return evt.Str(key, v.Value.(EnumWrap).ValueString)
-		}
 	}
 	return evt.Str(key, "(err)")
 }
@@ -379,7 +350,11 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 			v.DataType = datatype
 			return nil
 		} else {
-			v.Value = langext.Ptr(value[1:])
+			r, err := valueFromProto(value[1:], MDTString)
+			if err != nil {
+				return err
+			}
+			v.Value = langext.Ptr(r.Value.(string))
 			v.DataType = datatype
 			return nil
 		}
@@ -537,10 +512,6 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 		v.Value = nil
 		v.DataType = datatype
 		return nil
-	case MDTEnum:
-		v.Value = deserializeEnumWrap(value)
-		v.DataType = datatype
-		return nil
 	}
 	return errors.New("Unknown type: " + string(datatype))
 }
@@ -611,86 +582,53 @@ func (v MetaValue) ValueString() string {
 		return string(r)
 	case MDTNil:
 		return "<<null>>"
-	case MDTEnum:
-		return v.Value.(EnumWrap).String()
 	}
 	return "(err)"
 }
 
-// rawValueForJson returns most-of-the-time the `Value` field
-// but for some datatyes we do special processing
-// all, so we can pluck the output value in json.Marshal without any suprises
-func (v MetaValue) rawValueForJson() any {
-	if v.DataType == MDTAny {
-		if v.Value.(AnyWrap).IsNil {
-			return nil
+func valueFromProto(value string, datatype metaDataType) (MetaValue, error) {
+	obj := MetaValue{}
+	err := obj.Deserialize(value, datatype)
+	if err != nil {
+		return MetaValue{}, err
 	}
-		if v.Value.(AnyWrap).IsError {
-			return bson.M{"@error": true}
+	return obj, nil
+}
+
+func metaFromProto(proto []*spbmodels.CustomError_MetaValue) MetaMap {
+	r := make(MetaMap)
+
+	for _, v := range proto {
+		mval, err := valueFromProto(v.Value, metaDataType(v.Type))
+		if err != nil {
+			log.Warn().Err(err).Msg("metaFromProto failed for " + v.Key)
+			continue
 		}
-		jsonobj := primitive.M{}
-		jsonarr := primitive.A{}
-		if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonobj); err == nil {
-			return jsonobj
-		} else if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonarr); err == nil {
-			return jsonarr
-		} else {
-			return bson.M{"type": v.Value.(AnyWrap).Type, "data": v.Value.(AnyWrap).Json}
+		r[v.Key] = mval
 	}
+
+	return r
+}
+
+func (mm MetaMap) ToProto() []*spbmodels.CustomError_MetaValue {
+	if mm == nil {
+		return make([]*spbmodels.CustomError_MetaValue, 0)
 	}
-	if v.DataType == MDTID {
-		if v.Value.(IDWrap).IsNil {
-			return nil
+	r := make([]*spbmodels.CustomError_MetaValue, 0, len(mm))
+	for k, v := range mm {
+		strval, err := v.SerializeValue()
+		if err != nil {
+			log.Warn().Err(err).Msg("MetaMap.ToProto failed for " + k)
+			continue
 		}
-		return v.Value.(IDWrap).Value
+
+		r = append(r, &spbmodels.CustomError_MetaValue{
+			Key:   k,
+			Type:  string(v.DataType),
+			Value: strval,
+		})
 	}
-	if v.DataType == MDTBytes {
-		return hex.EncodeToString(v.Value.([]byte))
-	}
-	if v.DataType == MDTDuration {
-		return v.Value.(time.Duration).String()
-	}
-	if v.DataType == MDTTime {
-		return v.Value.(time.Time).Format(time.RFC3339Nano)
-	}
-	if v.DataType == MDTObjectID {
-		return v.Value.(primitive.ObjectID).Hex()
-	}
-	if v.DataType == MDTNil {
-		return nil
-	}
-	if v.DataType == MDTEnum {
-		if v.Value.(EnumWrap).IsNil {
-			return nil
-		}
-		if v.Value.(EnumWrap).ValueRaw != nil {
-			return v.Value.(EnumWrap).ValueRaw
-		}
-		return v.Value.(EnumWrap).ValueString
-	}
-	if v.DataType == MDTFloat32 {
-		if math.IsNaN(float64(v.Value.(float32))) {
-			return "float64::NaN"
-		} else if math.IsInf(float64(v.Value.(float32)), +1) {
-			return "float64::+inf"
-		} else if math.IsInf(float64(v.Value.(float32)), -1) {
-			return "float64::-inf"
-		} else {
-			return v.Value
-		}
-	}
-	if v.DataType == MDTFloat64 {
-		if math.IsNaN(v.Value.(float64)) {
-			return "float64::NaN"
-		} else if math.IsInf(v.Value.(float64), +1) {
-			return "float64::+inf"
-		} else if math.IsInf(v.Value.(float64), -1) {
-			return "float64::-inf"
-		} else {
-			return v.Value
-		}
-	}
-	return v.Value
+	return r
 }
 
 func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
@@ -737,9 +675,9 @@ func (mm MetaMap) Any() bool {
 	return len(mm) > 0
 }
 
-func (mm MetaMap) Apply(evt *zerolog.Event, limitLen *int) *zerolog.Event {
+func (mm MetaMap) Apply(evt *zerolog.Event) *zerolog.Event {
 	for key, val := range mm {
-		evt = val.Apply(key, evt, limitLen)
+		evt = val.Apply(key, evt)
 	}
 	return evt
 }

exerr/proxy.go

@@ -1,13 +0,0 @@
-package exerr
-
-type Proxy struct {
-	v ExErr
-}
-
-func (p *Proxy) UniqueID() string {
-	return p.v.UniqueID
-}
-
-func (p *Proxy) Get() ExErr {
-	return p.v
-}

exerr/wrapper.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/rs/zerolog/log"
-	"gogs.mikescher.com/BlackForestBytes/goext/enums"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"strings"
 )
@@ -132,58 +131,3 @@ func deserializeAnyWrap(v string) AnyWrap {
 		}
 	}
 }
-
-type EnumWrap struct {
-	Type        string
-	ValueString string
-	ValueRaw    enums.Enum // `ValueRaw` is lost during serialization roundtrip
-	IsNil       bool
-}
-
-func newEnumWrap(val enums.Enum) EnumWrap {
-	t := fmt.Sprintf("%T", val)
-	arr := strings.Split(t, ".")
-	if len(arr) > 0 {
-		t = arr[len(arr)-1]
-	}
-
-	if langext.IsNil(val) {
-		return EnumWrap{Type: t, ValueString: "", ValueRaw: val, IsNil: true}
-	}
-
-	if enumstr, ok := val.(enums.StringEnum); ok {
-		return EnumWrap{Type: t, ValueString: enumstr.String(), ValueRaw: val, IsNil: false}
-	}
-
-	return EnumWrap{Type: t, ValueString: fmt.Sprintf("%v", val), ValueRaw: val, IsNil: false}
-}
-
-func (w EnumWrap) Serialize() string {
-	if w.IsNil {
-		return "!nil" + ":" + w.Type
-	}
-	return w.Type + ":" + w.ValueString
-}
-
-func (w EnumWrap) String() string {
-	if w.IsNil {
-		return w.Type + "<<nil>>"
-	}
-	return "[" + w.Type + "] " + w.ValueString
-}
-
-func deserializeEnumWrap(v string) EnumWrap {
-	r := strings.SplitN(v, ":", 2)
-
-	if len(r) == 2 && r[0] == "!nil" {
-		return EnumWrap{Type: r[1], ValueString: v, ValueRaw: nil, IsNil: true}
-	}
-
-	if len(r) == 0 {
-		return EnumWrap{}
-	} else if len(r) == 1 {
-		return EnumWrap{Type: "", ValueString: v, ValueRaw: nil, IsNil: false}
-	} else {
-		return EnumWrap{Type: r[0], ValueString: r[1], ValueRaw: nil, IsNil: false}
-	}
-}

fsext/exists.go

@@ -1,36 +0,0 @@
-package fsext
-
-import "os"
-
-func PathExists(fp string) (bool, error) {
-	_, err := os.Stat(fp)
-	if err == nil {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}
-
-func FileExists(fp string) (bool, error) {
-	stat, err := os.Stat(fp)
-	if err == nil {
-		return !stat.IsDir(), nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}
-
-func DirectoryExists(fp string) (bool, error) {
-	stat, err := os.Stat(fp)
-	if err == nil {
-		return stat.IsDir(), nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}

ginext/appContext.go

@@ -1,59 +0,0 @@
-package ginext
-
-import (
-	"context"
-	"github.com/gin-gonic/gin"
-	"time"
-)
-
-type AppContext struct {
-	inner      context.Context
-	cancelFunc context.CancelFunc
-	cancelled  bool
-	GinContext *gin.Context
-}
-
-func CreateAppContext(g *gin.Context, innerCtx context.Context, cancelFn context.CancelFunc) *AppContext {
-	for key, value := range g.Keys {
-		innerCtx = context.WithValue(innerCtx, key, value)
-	}
-	return &AppContext{
-		inner:      innerCtx,
-		cancelFunc: cancelFn,
-		cancelled:  false,
-		GinContext: g,
-	}
-}
-
-func (ac *AppContext) Deadline() (deadline time.Time, ok bool) {
-	return ac.inner.Deadline()
-}
-
-func (ac *AppContext) Done() <-chan struct{} {
-	return ac.inner.Done()
-}
-
-func (ac *AppContext) Err() error {
-	return ac.inner.Err()
-}
-
-func (ac *AppContext) Value(key any) any {
-	return ac.inner.Value(key)
-}
-
-func (ac *AppContext) Set(key, value any) {
-	ac.inner = context.WithValue(ac.inner, key, value)
-}
-
-func (ac *AppContext) Cancel() {
-	ac.cancelled = true
-	ac.cancelFunc()
-}
-
-func (ac *AppContext) RequestURI() string {
-	if ac.GinContext != nil && ac.GinContext.Request != nil {
-		return ac.GinContext.Request.Method + " :: " + ac.GinContext.Request.RequestURI
-	} else {
-		return ""
-	}
-}

ginext/commonHandler.go

@@ -1,23 +0,0 @@
-package ginext
-
-import (
-	"net/http"
-)
-
-func RedirectFound(newuri string) WHandlerFunc {
-	return func(pctx PreContext) HTTPResponse {
-		return Redirect(http.StatusFound, newuri)
-	}
-}
-
-func RedirectTemporary(newuri string) WHandlerFunc {
-	return func(pctx PreContext) HTTPResponse {
-		return Redirect(http.StatusTemporaryRedirect, newuri)
-	}
-}
-
-func RedirectPermanent(newuri string) WHandlerFunc {
-	return func(pctx PreContext) HTTPResponse {
-		return Redirect(http.StatusPermanentRedirect, newuri)
-	}
-}

ginext/commonMiddlewares.go

@@ -1,12 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
-)
-
-func BodyBuffer(g *gin.Context) {
-	if g.Request.Body != nil {
-		g.Request.Body = dataext.NewBufferedReadCloser(g.Request.Body)
-	}
-}

ginext/cors.go

@@ -1,25 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-func CorsMiddleware(allowheader []string, exposeheader []string) gin.HandlerFunc {
-	return func(c *gin.Context) {
-		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
-		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
-		c.Writer.Header().Set("Access-Control-Allow-Headers", strings.Join(allowheader, ", "))
-		if len(exposeheader) > 0 {
-			c.Writer.Header().Set("Access-Control-Expose-Headers", strings.Join(exposeheader, ", "))
-		}
-		c.Writer.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE, COUNT")
-
-		if c.Request.Method == "OPTIONS" {
-			c.AbortWithStatus(http.StatusOK)
-		} else {
-			c.Next()
-		}
-	}
-}

ginext/engine.go

@@ -1,238 +0,0 @@
-package ginext
-
-import (
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"github.com/rs/zerolog/log"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"strings"
-	"time"
-)
-
-type GinWrapper struct {
-	engine          *gin.Engine
-	suppressGinLogs bool
-
-	opt                   Options
-	allowCors             bool
-	corsAllowHeader       []string
-	corsExposeHeader      []string
-	ginDebug              bool
-	bufferBody            bool
-	requestTimeout        time.Duration
-	listenerBeforeRequest []func(g *gin.Context)
-	listenerAfterRequest  []func(g *gin.Context, resp HTTPResponse)
-
-	buildRequestBindError func(g *gin.Context, fieldtype string, err error) HTTPResponse
-
-	routeSpecs []ginRouteSpec
-}
-
-type ginRouteSpec struct {
-	Method      string
-	URL         string
-	Middlewares []string
-	Handler     string
-}
-
-type Options struct {
-	AllowCors                *bool                                                          // Add cors handler to allow all CORS requests on the default http methods
-	CorsAllowHeader          *[]string                                                      // override the default values of Access-Control-Allow-Headers (AllowCors must be true)
-	CorsExposeHeader         *[]string                                                      // return Access-Control-Expose-Headers (AllowCors must be true)
-	GinDebug                 *bool                                                          // Set gin.debug to true (adds more logs)
-	SuppressGinLogs          *bool                                                          // Suppress our custom gin logs (even if GinDebug == true)
-	BufferBody               *bool                                                          // Buffers the input body stream, this way the ginext error handler can later include the whole request body
-	Timeout                  *time.Duration                                                 // The default handler timeout
-	ListenerBeforeRequest    []func(g *gin.Context)                                         // Register listener that are called before the handler method
-	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse)                      // Register listener that are called after the handler method
-	DebugTrimHandlerPrefixes []string                                                       // Trim these prefixes from the handler names in the debug print
-	DebugReplaceHandlerNames map[string]string                                              // Replace handler names in debug output
-	BuildRequestBindError    func(g *gin.Context, fieldtype string, err error) HTTPResponse // Override function which generates the HTTPResponse errors that are returned by the preContext..Start() methids
-}
-
-// NewEngine creates a new (wrapped) ginEngine
-func NewEngine(opt Options) *GinWrapper {
-	ginDebug := langext.Coalesce(opt.GinDebug, true)
-	if ginDebug {
-		gin.SetMode(gin.DebugMode)
-
-		// do not debug-print routes
-		gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
-
-	} else {
-		gin.SetMode(gin.ReleaseMode)
-
-		// do not debug-print routes
-		gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
-	}
-
-	engine := gin.New()
-
-	wrapper := &GinWrapper{
-		engine:                engine,
-		opt:                   opt,
-		suppressGinLogs:       langext.Coalesce(opt.SuppressGinLogs, false),
-		allowCors:             langext.Coalesce(opt.AllowCors, false),
-		corsAllowHeader:       langext.Coalesce(opt.CorsAllowHeader, []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization", "accept", "origin", "Cache-Control", "X-Requested-With"}),
-		corsExposeHeader:      langext.Coalesce(opt.CorsExposeHeader, []string{}),
-		ginDebug:              ginDebug,
-		bufferBody:            langext.Coalesce(opt.BufferBody, false),
-		requestTimeout:        langext.Coalesce(opt.Timeout, 24*time.Hour),
-		listenerBeforeRequest: opt.ListenerBeforeRequest,
-		listenerAfterRequest:  opt.ListenerAfterRequest,
-		buildRequestBindError: langext.Conditional(opt.BuildRequestBindError == nil, defaultBuildRequestBindError, opt.BuildRequestBindError),
-	}
-
-	engine.RedirectFixedPath = false
-	engine.RedirectTrailingSlash = false
-
-	if wrapper.allowCors {
-		engine.Use(CorsMiddleware(wrapper.corsAllowHeader, wrapper.corsExposeHeader))
-	}
-
-	if ginDebug && !wrapper.suppressGinLogs {
-		ginlogger := gin.Logger()
-		engine.Use(func(context *gin.Context) { ginlogger(context) })
-	}
-	return wrapper
-}
-
-func (w *GinWrapper) ListenAndServeHTTP(addr string, postInit func(port string)) (chan error, *http.Server) {
-
-	w.DebugPrintRoutes()
-
-	httpserver := &http.Server{
-		Addr:    addr,
-		Handler: w.engine,
-	}
-
-	errChan := make(chan error)
-
-	go func() {
-
-		ln, err := net.Listen("tcp", httpserver.Addr)
-		if err != nil {
-			errChan <- err
-			return
-		}
-
-		_, port, err := net.SplitHostPort(ln.Addr().String())
-		if err != nil {
-			errChan <- err
-			return
-		}
-
-		log.Info().Str("address", httpserver.Addr).Msg("HTTP-Server started on http://localhost:" + port)
-
-		if postInit != nil {
-			postInit(port) // the net.Listener a few lines above is at this point actually already buffering requests
-		}
-
-		errChan <- httpserver.Serve(ln)
-	}()
-
-	return errChan, httpserver
-}
-
-func (w *GinWrapper) DebugPrintRoutes() {
-	if !w.ginDebug {
-		return
-	}
-
-	lines := make([][4]string, 0)
-
-	pad := [4]int{0, 0, 0, 0}
-
-	for _, spec := range w.routeSpecs {
-
-		line := [4]string{
-			spec.Method,
-			spec.URL,
-			strings.Join(langext.ArrMap(spec.Middlewares, w.cleanMiddlewareName), " -> "),
-			w.cleanMiddlewareName(spec.Handler),
-		}
-
-		lines = append(lines, line)
-
-		pad[0] = mathext.Max(pad[0], len(line[0]))
-		pad[1] = mathext.Max(pad[1], len(line[1]))
-		pad[2] = mathext.Max(pad[2], len(line[2]))
-		pad[3] = mathext.Max(pad[3], len(line[3]))
-	}
-
-	fmt.Printf("Gin-Routes:\n")
-	fmt.Printf("{\n")
-	for _, line := range lines {
-
-		fmt.Printf(" %s  %s  -->  %s  -->  %s\n",
-			langext.StrPadRight("["+line[0]+"]", " ", pad[0]+2),
-			langext.StrPadRight(line[1], " ", pad[1]),
-			langext.StrPadRight(line[2], " ", pad[2]),
-			langext.StrPadRight(line[3], " ", pad[3]))
-	}
-	fmt.Printf("}\n")
-}
-
-func (w *GinWrapper) cleanMiddlewareName(fname string) string {
-
-	funcSuffix := rext.W(regexp.MustCompile(`\.func[0-9]+(?:\.[0-9]+)*$`))
-	if match, ok := funcSuffix.MatchFirst(fname); ok {
-		fname = fname[:len(fname)-match.FullMatch().Length()]
-	}
-
-	if strings.HasSuffix(fname, ".(*GinRoutesWrapper).WithJSONFilter") {
-		fname = "[JSONFilter]"
-	}
-
-	if fname == "ginext.BodyBuffer" {
-		fname = "[BodyBuffer]"
-	}
-
-	skipPrefixes := []string{"api.(*Handler).", "api.", "ginext.", "handler.", "admin-app.", "employee-app.", "employer-app."}
-	for _, pfx := range skipPrefixes {
-		if strings.HasPrefix(fname, pfx) {
-			fname = fname[len(pfx):]
-		}
-	}
-
-	for _, pfx := range w.opt.DebugTrimHandlerPrefixes {
-		if strings.HasPrefix(fname, pfx) {
-			fname = fname[len(pfx):]
-		}
-	}
-
-	for k, v := range langext.ForceMap(w.opt.DebugReplaceHandlerNames) {
-		if strings.EqualFold(fname, k) {
-			fname = v
-		}
-	}
-
-	return fname
-}
-
-// ServeHTTP only used for unit tests
-func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
-	respRec := httptest.NewRecorder()
-	w.engine.ServeHTTP(respRec, req)
-	return respRec
-}
-
-// ForwardRequest manually inserts a request into this router
-// = behaves as if the request came from the outside (and writes the response to `writer`)
-func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
-	w.engine.ServeHTTP(writer, req)
-}
-
-func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
-	return w.engine.Routes()
-}
-
-func defaultBuildRequestBindError(g *gin.Context, fieldtype string, err error) HTTPResponse {
-	return Error(err)
-}

ginext/funcWrapper.go

@@ -1,60 +0,0 @@
-package ginext
-
-import (
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-)
-
-type WHandlerFunc func(PreContext) HTTPResponse
-
-func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
-
-	return func(g *gin.Context) {
-
-		reqctx := g.Request.Context()
-
-		pctx := PreContext{
-			wrapper:        w,
-			ginCtx:         g,
-			persistantData: &preContextData{},
-		}
-
-		for _, lstr := range w.listenerBeforeRequest {
-			lstr(g)
-		}
-
-		wrap, stackTrace, panicObj := callPanicSafe(fn, pctx)
-		if panicObj != nil {
-
-			fmt.Printf("\n======== ======== STACKTRACE ======== ========\n%s\n======== ======== ======== ========\n\n", stackTrace)
-
-			err := exerr.
-				New(exerr.TypePanic, "Panic occured (in gin handler)").
-				Any("panicObj", panicObj).
-				Str("trace", stackTrace).
-				Build()
-
-			wrap = Error(err)
-		}
-
-		if g.Writer.Written() {
-			panic("Writing in WrapperFunc is not supported")
-		}
-
-		if pctx.persistantData.sessionObj != nil {
-			err := pctx.persistantData.sessionObj.Finish(reqctx, wrap)
-			if err != nil {
-				wrap = Error(exerr.Wrap(err, "Failed to finish session").Any("originalResponse", wrap).Build())
-			}
-		}
-
-		for _, lstr := range w.listenerAfterRequest {
-			lstr(g, wrap)
-		}
-
-		if reqctx.Err() == nil {
-			wrap.Write(g)
-		}
-	}
-}

ginext/jsonFilter.go

@@ -1,9 +0,0 @@
-package ginext
-
-import "github.com/gin-gonic/gin"
-
-var jsonFilterKey = "goext.jsonfilter"
-
-func SetJSONFilter(g *gin.Context, filter string) {
-	g.Set(jsonFilterKey, filter)
-}

ginext/preContext.go

@@ -1,211 +0,0 @@
-package ginext
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"github.com/gin-gonic/gin/binding"
-	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"io"
-	"runtime/debug"
-	"time"
-)
-
-type PreContext struct {
-	ginCtx                 *gin.Context
-	wrapper                *GinWrapper
-	uri                    any
-	query                  any
-	body                   any
-	rawbody                *[]byte
-	form                   any
-	header                 any
-	timeout                *time.Duration
-	persistantData         *preContextData // must be a ptr, so that we can get the values back in out Wrap func
-	ignoreWrongContentType bool
-}
-
-type preContextData struct {
-	sessionObj SessionObject
-}
-
-func (pctx *PreContext) URI(uri any) *PreContext {
-	pctx.uri = uri
-	return pctx
-}
-
-func (pctx *PreContext) Query(query any) *PreContext {
-	pctx.query = query
-	return pctx
-}
-
-func (pctx *PreContext) Body(body any) *PreContext {
-	pctx.body = body
-	return pctx
-}
-
-func (pctx *PreContext) RawBody(rawbody *[]byte) *PreContext {
-	pctx.rawbody = rawbody
-	return pctx
-}
-
-func (pctx *PreContext) Form(form any) *PreContext {
-	pctx.form = form
-	return pctx
-}
-
-func (pctx *PreContext) Header(header any) *PreContext {
-	pctx.header = header
-	return pctx
-}
-
-func (pctx *PreContext) WithTimeout(to time.Duration) *PreContext {
-	pctx.timeout = &to
-	return pctx
-}
-
-func (pctx *PreContext) WithSession(sessionObj SessionObject) *PreContext {
-	pctx.persistantData.sessionObj = sessionObj
-	return pctx
-}
-
-func (pctx *PreContext) IgnoreWrongContentType() *PreContext {
-	pctx.ignoreWrongContentType = true
-	return pctx
-}
-
-func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
-	if pctx.uri != nil {
-		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
-			err = exerr.Wrap(err, "Failed to read uri").
-				WithType(exerr.TypeBindFailURI).
-				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
-				Build()
-			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
-		}
-	}
-
-	if pctx.query != nil {
-		if err := pctx.ginCtx.ShouldBindQuery(pctx.query); err != nil {
-			err = exerr.Wrap(err, "Failed to read query").
-				WithType(exerr.TypeBindFailQuery).
-				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
-				Build()
-			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
-		}
-	}
-
-	if pctx.body != nil {
-		if pctx.ginCtx.ContentType() == "application/json" {
-			if brc, ok := pctx.body.(dataext.BufferedReadCloser); ok {
-				// Ensures a fully reset (offset=0) buffer before parsing
-				err := brc.Reset()
-				if err != nil {
-					err = exerr.Wrap(err, "Failed to read (brc.reset) json-body").
-						WithType(exerr.TypeBindFailJSON).
-						Str("struct_type", fmt.Sprintf("%T", pctx.body)).
-						Build()
-					return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
-				}
-			}
-			if err := pctx.ginCtx.ShouldBindJSON(pctx.body); err != nil {
-				err = exerr.Wrap(err, "Failed to read json-body").
-					WithType(exerr.TypeBindFailJSON).
-					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
-					Build()
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
-			}
-		} else {
-			if !pctx.ignoreWrongContentType {
-				err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
-					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
-					Build()
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
-			}
-		}
-	}
-
-	if pctx.rawbody != nil {
-		if brc, ok := pctx.ginCtx.Request.Body.(dataext.BufferedReadCloser); ok {
-			v, err := brc.BufferedAll()
-			if err != nil {
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
-			}
-			*pctx.rawbody = v
-		} else {
-			buf := &bytes.Buffer{}
-			_, err := io.Copy(buf, pctx.ginCtx.Request.Body)
-			if err != nil {
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
-			}
-			*pctx.rawbody = buf.Bytes()
-		}
-	}
-
-	if pctx.form != nil {
-		if pctx.ginCtx.ContentType() == "multipart/form-data" {
-			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
-				err = exerr.Wrap(err, "Failed to read multipart-form").
-					WithType(exerr.TypeBindFailFormData).
-					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
-					Build()
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
-			}
-		} else if pctx.ginCtx.ContentType() == "application/x-www-form-urlencoded" {
-			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
-				err = exerr.Wrap(err, "Failed to read urlencoded-form").
-					WithType(exerr.TypeBindFailFormData).
-					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
-					Build()
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
-			}
-		} else {
-			if !pctx.ignoreWrongContentType {
-				err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
-					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
-					Build()
-				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
-			}
-		}
-	}
-
-	if pctx.header != nil {
-		if err := pctx.ginCtx.ShouldBindHeader(pctx.header); err != nil {
-			err = exerr.Wrap(err, "Failed to read header").
-				WithType(exerr.TypeBindFailHeader).
-				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
-				Build()
-			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
-		}
-	}
-
-	ictx, cancel := context.WithTimeout(context.Background(), langext.Coalesce(pctx.timeout, pctx.wrapper.requestTimeout))
-
-	actx := CreateAppContext(pctx.ginCtx, ictx, cancel)
-
-	if pctx.persistantData.sessionObj != nil {
-		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, actx)
-		if err != nil {
-			actx.Cancel()
-			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
-		}
-	}
-
-	return actx, pctx.ginCtx, nil
-}
-
-func callPanicSafe(fn WHandlerFunc, pctx PreContext) (res HTTPResponse, stackTrace string, panicObj any) {
-	defer func() {
-		if rec := recover(); rec != nil {
-			res = nil
-			stackTrace = string(debug.Stack())
-			panicObj = rec
-		}
-	}()
-
-	res = fn(pctx)
-	return res, "", nil
-}

ginext/response.go

@@ -1,47 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-)
-
-type cookieval struct {
-	name     string
-	value    string
-	maxAge   int
-	path     string
-	domain   string
-	secure   bool
-	httpOnly bool
-}
-
-type headerval struct {
-	Key string
-	Val string
-}
-
-type HTTPResponse interface {
-	Write(g *gin.Context)
-	WithHeader(k string, v string) HTTPResponse
-	WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse
-	IsSuccess() bool
-}
-
-type InspectableHTTPResponse interface {
-	HTTPResponse
-
-	Statuscode() int
-	BodyString(g *gin.Context) *string
-	ContentType() string
-	Headers() []string
-}
-
-type HTTPErrorResponse interface {
-	HTTPResponse
-
-	Error() error
-}
-
-func NotImplemented() HTTPResponse {
-	return Error(exerr.New(exerr.TypeNotImplemented, "").Build())
-}

ginext/responseData.go

@@ -1,58 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type dataHTTPResponse struct {
-	statusCode  int
-	data        []byte
-	contentType string
-	headers     []headerval
-	cookies     []cookieval
-}
-
-func (j dataHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.Data(j.statusCode, j.contentType, j.data)
-}
-
-func (j dataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j dataHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j dataHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j dataHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j dataHTTPResponse) BodyString(*gin.Context) *string {
-	return langext.Ptr(string(j.data))
-}
-
-func (j dataHTTPResponse) ContentType() string {
-	return j.contentType
-}
-
-func (j dataHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func Data(sc int, contentType string, data []byte) HTTPResponse {
-	return &dataHTTPResponse{statusCode: sc, contentType: contentType, data: data}
-}

ginext/responseDownload.go

@@ -1,64 +0,0 @@
-package ginext
-
-import (
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type downloadDataHTTPResponse struct {
-	statusCode int
-	mimetype   string
-	data       []byte
-	filename   *string
-	headers    []headerval
-	cookies    []cookieval
-}
-
-func (j downloadDataHTTPResponse) Write(g *gin.Context) {
-	g.Header("Content-Type", j.mimetype) // if we don't set it here gin does weird file-sniffing later...
-	if j.filename != nil {
-		g.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", *j.filename))
-	}
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.Data(j.statusCode, j.mimetype, j.data)
-}
-
-func (j downloadDataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j downloadDataHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j downloadDataHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j downloadDataHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j downloadDataHTTPResponse) BodyString(*gin.Context) *string {
-	return langext.Ptr(string(j.data))
-}
-
-func (j downloadDataHTTPResponse) ContentType() string {
-	return j.mimetype
-}
-
-func (j downloadDataHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func DownloadData(status int, mimetype string, filename string, data []byte) HTTPResponse {
-	return &downloadDataHTTPResponse{statusCode: status, mimetype: mimetype, data: data, filename: &filename}
-}

ginext/responseEmpty.go

@@ -1,56 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type emptyHTTPResponse struct {
-	statusCode int
-	headers    []headerval
-	cookies    []cookieval
-}
-
-func (j emptyHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.Status(j.statusCode)
-}
-
-func (j emptyHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j emptyHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j emptyHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j emptyHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j emptyHTTPResponse) BodyString(*gin.Context) *string {
-	return nil
-}
-
-func (j emptyHTTPResponse) ContentType() string {
-	return ""
-}
-
-func (j emptyHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func Status(sc int) HTTPResponse {
-	return &emptyHTTPResponse{statusCode: sc}
-}

ginext/responseFile.go

@@ -1,73 +0,0 @@
-package ginext
-
-import (
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"os"
-)
-
-type fileHTTPResponse struct {
-	mimetype string
-	filepath string
-	filename *string
-	headers  []headerval
-	cookies  []cookieval
-}
-
-func (j fileHTTPResponse) Write(g *gin.Context) {
-	g.Header("Content-Type", j.mimetype) // if we don't set it here gin does weird file-sniffing later...
-	if j.filename != nil {
-		g.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", *j.filename))
-
-	}
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.File(j.filepath)
-}
-
-func (j fileHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j fileHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j fileHTTPResponse) IsSuccess() bool {
-	return true
-}
-
-func (j fileHTTPResponse) Statuscode() int {
-	return 200
-}
-
-func (j fileHTTPResponse) BodyString(*gin.Context) *string {
-	data, err := os.ReadFile(j.filepath)
-	if err != nil {
-		return nil
-	}
-	return langext.Ptr(string(data))
-}
-
-func (j fileHTTPResponse) ContentType() string {
-	return j.mimetype
-}
-
-func (j fileHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func File(mimetype string, filepath string) HTTPResponse {
-	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath}
-}
-
-func Download(mimetype string, filepath string, filename string) HTTPResponse {
-	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath, filename: &filename}
-}

ginext/responseJson.go

@@ -1,78 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type jsonHTTPResponse struct {
-	statusCode     int
-	data           any
-	headers        []headerval
-	cookies        []cookieval
-	filterOverride *string
-}
-
-func (j jsonHTTPResponse) jsonRenderer(g *gin.Context) json.GoJsonRender {
-	var f *string
-	if jsonfilter := g.GetString(jsonFilterKey); jsonfilter != "" {
-		f = &jsonfilter
-	}
-	if j.filterOverride != nil {
-		f = j.filterOverride
-	}
-	return json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true, Filter: f}
-}
-
-func (j jsonHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.Render(j.statusCode, j.jsonRenderer(g))
-}
-
-func (j jsonHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j jsonHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j jsonHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j jsonHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j jsonHTTPResponse) BodyString(g *gin.Context) *string {
-	if str, err := j.jsonRenderer(g).RenderString(); err == nil {
-		return &str
-	} else {
-		return nil
-	}
-}
-
-func (j jsonHTTPResponse) ContentType() string {
-	return "application/json"
-}
-
-func (j jsonHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func JSON(sc int, data any) HTTPResponse {
-	return &jsonHTTPResponse{statusCode: sc, data: data}
-}
-
-func JSONWithFilter(sc int, data any, f string) HTTPResponse {
-	return &jsonHTTPResponse{statusCode: sc, data: data, filterOverride: &f}
-}

ginext/responseJsonAPI.go

@@ -1,81 +0,0 @@
-package ginext
-
-import (
-	"context"
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type jsonAPIErrResponse struct {
-	err     *exerr.ExErr
-	headers []headerval
-	cookies []cookieval
-}
-
-func (j jsonAPIErrResponse) Error() error {
-	return j.err
-}
-
-func (j jsonAPIErrResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-
-	exerr.Get(j.err).Output(context.Background(), g)
-
-	j.err.CallListener(exerr.MethodOutput)
-}
-
-func (j jsonAPIErrResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j jsonAPIErrResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j jsonAPIErrResponse) IsSuccess() bool {
-	return false
-}
-
-func (j jsonAPIErrResponse) Statuscode() int {
-	return langext.Coalesce(j.err.RecursiveStatuscode(), 0)
-}
-
-func (j jsonAPIErrResponse) BodyString(*gin.Context) *string {
-	if str, err := j.err.ToDefaultAPIJson(); err == nil {
-		return &str
-	} else {
-		return nil
-	}
-}
-
-func (j jsonAPIErrResponse) ContentType() string {
-	return "application/json"
-}
-
-func (j jsonAPIErrResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func (j jsonAPIErrResponse) Unwrap() error {
-	return j.err
-}
-
-func Error(e error) HTTPResponse {
-	return &jsonAPIErrResponse{
-		err: exerr.FromError(e),
-	}
-}
-
-func ErrWrap(e error, errorType exerr.ErrorType, msg string) HTTPResponse {
-	return &jsonAPIErrResponse{
-		err: exerr.FromError(exerr.Wrap(e, msg).WithType(errorType).Build()),
-	}
-}

ginext/responseRedirect.go

@@ -1,57 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type redirectHTTPResponse struct {
-	statusCode int
-	url        string
-	headers    []headerval
-	cookies    []cookieval
-}
-
-func (j redirectHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.Redirect(j.statusCode, j.url)
-}
-
-func (j redirectHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j redirectHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j redirectHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j redirectHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j redirectHTTPResponse) BodyString(*gin.Context) *string {
-	return nil
-}
-
-func (j redirectHTTPResponse) ContentType() string {
-	return ""
-}
-
-func (j redirectHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func Redirect(sc int, newURL string) HTTPResponse {
-	return &redirectHTTPResponse{statusCode: sc, url: newURL}
-}

ginext/responseSeekable.go

@@ -1,72 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"io"
-	"net/http"
-	"time"
-)
-
-type seekableResponse struct {
-	data        io.ReadSeeker
-	contentType string
-	filename    string
-	headers     []headerval
-	cookies     []cookieval
-}
-
-func (j seekableResponse) Write(g *gin.Context) {
-	g.Header("Content-Type", j.contentType) // if we don't set it here http.ServeContent does weird sniffing later...
-
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-
-	http.ServeContent(g.Writer, g.Request, j.filename, time.Unix(0, 0), j.data)
-
-	if clsr, ok := j.data.(io.ReadSeekCloser); ok {
-		err := clsr.Close()
-		if err != nil {
-			exerr.Wrap(err, "failed to close io.ReadSeerkClose in ginext.Seekable").Str("filename", j.filename).Print()
-		}
-	}
-}
-
-func (j seekableResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j seekableResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j seekableResponse) IsSuccess() bool {
-	return true
-}
-
-func (j seekableResponse) Statuscode() int {
-	return 200
-}
-
-func (j seekableResponse) BodyString(*gin.Context) *string {
-	return langext.Ptr("(seekable)")
-}
-
-func (j seekableResponse) ContentType() string {
-	return j.contentType
-}
-
-func (j seekableResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func Seekable(filename string, contentType string, data io.ReadSeeker) HTTPResponse {
-	return &seekableResponse{filename: filename, contentType: contentType, data: data}
-}

ginext/responseText.go

@@ -1,57 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-)
-
-type textHTTPResponse struct {
-	statusCode int
-	data       string
-	headers    []headerval
-	cookies    []cookieval
-}
-
-func (j textHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
-	for _, v := range j.cookies {
-		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
-	}
-	g.String(j.statusCode, "%s", j.data)
-}
-
-func (j textHTTPResponse) WithHeader(k string, v string) HTTPResponse {
-	j.headers = append(j.headers, headerval{k, v})
-	return j
-}
-
-func (j textHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
-	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
-	return j
-}
-
-func (j textHTTPResponse) IsSuccess() bool {
-	return j.statusCode >= 200 && j.statusCode <= 399
-}
-
-func (j textHTTPResponse) Statuscode() int {
-	return j.statusCode
-}
-
-func (j textHTTPResponse) BodyString(*gin.Context) *string {
-	return langext.Ptr(j.data)
-}
-
-func (j textHTTPResponse) ContentType() string {
-	return "text/plain"
-}
-
-func (j textHTTPResponse) Headers() []string {
-	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
-}
-
-func Text(sc int, data string) HTTPResponse {
-	return &textHTTPResponse{statusCode: sc, data: data}
-}

ginext/routes.go

@@ -1,211 +0,0 @@
-package ginext
-
-import (
-	"github.com/gin-gonic/gin"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"net/http"
-	"path"
-	"reflect"
-	"runtime"
-	"strings"
-)
-
-var anyMethods = []string{
-	http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch,
-	http.MethodHead, http.MethodOptions, http.MethodDelete, http.MethodConnect,
-	http.MethodTrace,
-}
-
-type GinRoutesWrapper struct {
-	wrapper        *GinWrapper
-	routes         gin.IRouter
-	absPath        string
-	defaultHandler []gin.HandlerFunc
-}
-
-type GinRouteBuilder struct {
-	routes *GinRoutesWrapper
-
-	method   string
-	relPath  string
-	absPath  string
-	handlers []gin.HandlerFunc
-}
-
-func (w *GinWrapper) Routes() *GinRoutesWrapper {
-	return &GinRoutesWrapper{
-		wrapper:        w,
-		routes:         w.engine,
-		absPath:        "",
-		defaultHandler: make([]gin.HandlerFunc, 0),
-	}
-}
-
-func (w *GinRoutesWrapper) Group(relativePath string) *GinRoutesWrapper {
-	return &GinRoutesWrapper{
-		wrapper:        w.wrapper,
-		routes:         w.routes.Group(relativePath),
-		defaultHandler: langext.ArrCopy(w.defaultHandler),
-		absPath:        joinPaths(w.absPath, relativePath),
-	}
-}
-
-func (w *GinRoutesWrapper) Use(middleware ...gin.HandlerFunc) *GinRoutesWrapper {
-	defHandler := langext.ArrCopy(w.defaultHandler)
-	defHandler = append(defHandler, middleware...)
-	return &GinRoutesWrapper{wrapper: w.wrapper, routes: w.routes, defaultHandler: defHandler, absPath: w.absPath}
-}
-
-func (w *GinRoutesWrapper) WithJSONFilter(filter string) *GinRoutesWrapper {
-	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
-}
-
-func (w *GinRoutesWrapper) GET(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodGet, relativePath)
-}
-
-func (w *GinRoutesWrapper) POST(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodPost, relativePath)
-}
-
-func (w *GinRoutesWrapper) DELETE(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodDelete, relativePath)
-}
-
-func (w *GinRoutesWrapper) PATCH(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodPatch, relativePath)
-}
-
-func (w *GinRoutesWrapper) PUT(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodPut, relativePath)
-}
-
-func (w *GinRoutesWrapper) OPTIONS(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodOptions, relativePath)
-}
-
-func (w *GinRoutesWrapper) HEAD(relativePath string) *GinRouteBuilder {
-	return w._route(http.MethodHead, relativePath)
-}
-
-func (w *GinRoutesWrapper) COUNT(relativePath string) *GinRouteBuilder {
-	return w._route("COUNT", relativePath)
-}
-
-func (w *GinRoutesWrapper) Any(relativePath string) *GinRouteBuilder {
-	return w._route("*", relativePath)
-}
-
-func (w *GinRoutesWrapper) _route(method string, relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{
-		routes:   w,
-		method:   method,
-		relPath:  relativePath,
-		absPath:  joinPaths(w.absPath, relativePath),
-		handlers: langext.ArrCopy(w.defaultHandler),
-	}
-}
-
-func (w *GinRouteBuilder) Use(middleware ...gin.HandlerFunc) *GinRouteBuilder {
-	w.handlers = append(w.handlers, middleware...)
-	return w
-}
-
-func (w *GinRouteBuilder) WithJSONFilter(filter string) *GinRouteBuilder {
-	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
-}
-
-func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {
-
-	if w.routes.wrapper.bufferBody {
-		arr := make([]gin.HandlerFunc, 0, len(w.handlers)+1)
-		arr = append(arr, BodyBuffer)
-		arr = append(arr, w.handlers...)
-		w.handlers = arr
-	}
-
-	middlewareNames := langext.ArrMap(w.handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
-	handlerName := nameOfFunction(handler)
-
-	w.handlers = append(w.handlers, Wrap(w.routes.wrapper, handler))
-
-	methodName := w.method
-
-	if w.method == "*" {
-		methodName = "ANY"
-		for _, method := range anyMethods {
-			w.routes.routes.Handle(method, w.relPath, w.handlers...)
-		}
-	} else {
-		w.routes.routes.Handle(w.method, w.relPath, w.handlers...)
-	}
-
-	w.routes.wrapper.routeSpecs = append(w.routes.wrapper.routeSpecs, ginRouteSpec{
-		Method:      methodName,
-		URL:         w.absPath,
-		Middlewares: middlewareNames,
-		Handler:     handlerName,
-	})
-}
-
-func (w *GinWrapper) NoRoute(handler WHandlerFunc) {
-
-	handlers := make([]gin.HandlerFunc, 0)
-
-	if w.bufferBody {
-		handlers = append(handlers, BodyBuffer)
-	}
-
-	middlewareNames := langext.ArrMap(handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
-	handlerName := nameOfFunction(handler)
-
-	handlers = append(handlers, Wrap(w, handler))
-
-	w.engine.NoRoute(handlers...)
-
-	w.routeSpecs = append(w.routeSpecs, ginRouteSpec{
-		Method:      "ANY",
-		URL:         "[NO_ROUTE]",
-		Middlewares: middlewareNames,
-		Handler:     handlerName,
-	})
-}
-
-func nameOfFunction(f any) string {
-
-	fname := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
-
-	split := strings.Split(fname, "/")
-	if len(split) == 0 {
-		return ""
-	}
-
-	fname = split[len(split)-1]
-
-	// https://stackoverflow.com/a/32925345/1761622
-	if strings.HasSuffix(fname, "-fm") {
-		fname = fname[:len(fname)-len("-fm")]
-	}
-
-	return fname
-}
-
-// joinPaths is copied verbatim from gin@v1.9.1/gin.go
-func joinPaths(absolutePath, relativePath string) string {
-	if relativePath == "" {
-		return absolutePath
-	}
-
-	finalPath := path.Join(absolutePath, relativePath)
-	if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
-		return finalPath + "/"
-	}
-	return finalPath
-}
-
-func lastChar(str string) uint8 {
-	if str == "" {
-		panic("The length of the string can't be 0")
-	}
-	return str[len(str)-1]
-}

ginext/session.go

@@ -1,11 +0,0 @@
-package ginext
-
-import (
-	"context"
-	"github.com/gin-gonic/gin"
-)
-
-type SessionObject interface {
-	Init(g *gin.Context, ctx *AppContext) error
-	Finish(ctx context.Context, resp HTTPResponse) error
-}

go.mod

@@ -1,64 +1,27 @@
 module gogs.mikescher.com/BlackForestBytes/goext
 
-go 1.23
+go 1.19
 
 require (
-	github.com/gin-gonic/gin v1.10.0
-	github.com/glebarez/go-sqlite v1.22.0 // only needed for tests -.-
-	github.com/jmoiron/sqlx v1.4.0
-	github.com/rs/xid v1.6.0
-	github.com/rs/zerolog v1.33.0
-	go.mongodb.org/mongo-driver v1.17.2
-	golang.org/x/crypto v0.32.0
-	golang.org/x/sys v0.29.0
-	golang.org/x/term v0.28.0
+	golang.org/x/sys v0.5.0
+	golang.org/x/term v0.3.0
 )
 
 require (
-	github.com/disintegration/imaging v1.6.2
-	github.com/jung-kurt/gofpdf v1.16.2
-	golang.org/x/sync v0.10.0
-)
-
-require (
-	github.com/bytedance/sonic v1.12.7 // indirect
-	github.com/bytedance/sonic/loader v0.2.2 // indirect
-	github.com/cloudwego/base64x v0.1.4 // indirect
-	github.com/cloudwego/iasm v0.2.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
-	github.com/gin-contrib/sse v1.0.0 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.23.0 // indirect
-	github.com/goccy/go-json v0.10.4 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/uuid v1.5.0 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.17.11 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/montanaflynn/stats v0.7.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.12 // indirect
+	github.com/golang/snappy v0.0.1 // indirect
+	github.com/jmoiron/sqlx v1.3.5 // indirect
+	github.com/klauspost/compress v1.13.6 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rs/zerolog v1.29.0 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
-	github.com/xdg-go/scram v1.1.2 // indirect
-	github.com/xdg-go/stringprep v1.0.4 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/arch v0.13.0 // indirect
-	golang.org/x/image v0.23.0 // indirect
-	golang.org/x/net v0.34.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
-	google.golang.org/protobuf v1.36.2 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-	modernc.org/libc v1.37.6 // indirect
-	modernc.org/mathutil v1.6.0 // indirect
-	modernc.org/memory v1.7.2 // indirect
-	modernc.org/sqlite v1.28.0 // indirect
+	github.com/xdg-go/scram v1.1.1 // indirect
+	github.com/xdg-go/stringprep v1.0.3 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
+	go.mongodb.org/mongo-driver v1.11.2 // indirect
+	golang.org/x/crypto v0.4.0 // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/text v0.5.0 // indirect
 )

go.sum

@@ -1,271 +1,78 @@
-filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
-filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/bytedance/sonic v1.12.3 h1:W2MGa7RCU1QTeYRTPE3+88mVC0yXmsRQRChiyVocVjU=
-github.com/bytedance/sonic v1.12.3/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
-github.com/bytedance/sonic v1.12.4 h1:9Csb3c9ZJhfUWeMtpCDCq6BUoH5ogfDFLUgQ/jG+R0k=
-github.com/bytedance/sonic v1.12.4/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
-github.com/bytedance/sonic v1.12.5 h1:hoZxY8uW+mT+OpkcUWw4k0fDINtOcVavEsGfzwzFU/w=
-github.com/bytedance/sonic v1.12.5/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
-github.com/bytedance/sonic v1.12.6 h1:/isNmCUF2x3Sh8RAp/4mh4ZGkcFAX/hLrzrK3AvpRzk=
-github.com/bytedance/sonic v1.12.6/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
-github.com/bytedance/sonic v1.12.7 h1:CQU8pxOy9HToxhndH0Kx/S1qU/CuS9GnKYrGioDcU1Q=
-github.com/bytedance/sonic v1.12.7/go.mod h1:tnbal4mxOMju17EGfknm2XyYcpyCnIROYOEYuemj13I=
-github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
-github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.1 h1:1GgorWTqf12TA8mma4DDSbaQigE2wOgQo7iCjjJv3+E=
-github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.2 h1:jxAJuN9fOot/cyz5Q6dUuMJF5OqQ6+5GfA8FjjQ0R4o=
-github.com/bytedance/sonic/loader v0.2.2/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
-github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
-github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
-github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
-github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
-github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
-github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
-github.com/gabriel-vasile/mimetype v1.4.6 h1:3+PzJTKLkvgjeTbts6msPJt4DixhT4YtFNf1gtGe3zc=
-github.com/gabriel-vasile/mimetype v1.4.6/go.mod h1:JX1qVKqZd40hUPpAfiNTe0Sne7hdfKSbOqqmkq8GCXc=
-github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
-github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
-github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
-github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
-github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
-github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
-github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
-github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
-github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
-github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
-github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
-github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
-github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
-github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
-github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
-github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
-github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
-github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
-github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
-github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
-github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
-github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
-github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
-github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
-github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
-github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
-github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
-github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
-github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
-github.com/jung-kurt/gofpdf v1.16.2 h1:jgbatWHfRlPYiK85qgevsZTHviWXKwB1TTiKdz5PtRc=
-github.com/jung-kurt/gofpdf v1.16.2/go.mod h1:1hl7y57EsiPAkLbOwzpzqgx1A30nQCk/YmFV8S2vmK0=
-github.com/klauspost/compress v1.17.10 h1:oXAz+Vh0PMUvJczoi+flxpnBEPxoER1IaAnU/NMPtT0=
-github.com/klauspost/compress v1.17.10/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
-github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
-github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
-github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
-github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
-github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
-github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
-github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
-github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
-github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
+github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
+github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
+github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
-github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
-github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
-github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
-github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
-github.com/phpdave11/gofpdi v1.0.7/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
-github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
-github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
+github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w=
+github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
-github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
-github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
-github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
-github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
-github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
-github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.mongodb.org/mongo-driver v1.17.1 h1:Wic5cJIwJgSpBhe3lx3+/RybR5PiYRMpVFgO7cOHyIM=
-go.mongodb.org/mongo-driver v1.17.1/go.mod h1:wwWm/+BuOddhcq3n68LKRmgk2wXzmF6s0SFOa0GINL4=
-go.mongodb.org/mongo-driver v1.17.2 h1:gvZyk8352qSfzyZ2UMWcpDpMSGEr1eqE4T793SqyhzM=
-go.mongodb.org/mongo-driver v1.17.2/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
-golang.org/x/arch v0.11.0 h1:KXV8WWKCXm6tRpLirl2szsO5j/oOODwZf4hATmGVNs4=
-golang.org/x/arch v0.11.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
-golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/arch v0.13.0 h1:KCkqVVV1kGg0X87TFysjCJ8MxtZEIU4Ja/yXGeoECdA=
-golang.org/x/arch v0.13.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
-golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
-golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY=
-golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.21.0 h1:c5qV36ajHpdj4Qi0GnE0jUc/yuo33OLFaa0d+crTD5s=
-golang.org/x/image v0.21.0/go.mod h1:vUbsLavqK/W303ZroQQVKQ+Af3Yl6Uz1Ppu5J/cLz78=
-golang.org/x/image v0.22.0 h1:UtK5yLUzilVrkjMAZAZ34DXGpASN8i8pj8g+O+yd10g=
-golang.org/x/image v0.22.0/go.mod h1:9hPFhljd4zZ1GNSIZJ49sqbp45GKK9t6w+iXvGqZUz4=
-golang.org/x/image v0.23.0 h1:HseQ7c2OpPKTPVzNjG5fwJsOTCiiwS4QdsYi5XU6H68=
-golang.org/x/image v0.23.0/go.mod h1:wJJBTdLfCCf3tiHa1fNxpZmUI4mmoZvwMCPP0ddoNKY=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
-golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
-golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
-golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
-golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
-golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
-golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
-golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
-golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+github.com/xdg-go/scram v1.1.1 h1:VOMT+81stJgXW3CpHyqHN3AXDYIMsx56mEFrB37Mb/E=
+github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
+github.com/xdg-go/stringprep v1.0.3 h1:kdwGpVNwPFtjs98xCGkHjQtGKh86rDcRZN17QEMCOIs=
+github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+go.mongodb.org/mongo-driver v1.11.2 h1:+1v2rDQUWNcGW7/7E0Jvdz51V38XXxJfhzbV17aNHCw=
+go.mongodb.org/mongo-driver v1.11.2/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
+golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
-golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
-golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
-golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
-golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
-golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
-golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/term v0.1.0 h1:g6Z6vPFA9dYBAF7DWcH6sCcOntplXsDKcliusYijMlw=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
-golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io=
-google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
-google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU=
-google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw=
-modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
-modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
-modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
-modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
-modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
-modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
-modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=
-nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

goextVersion.go

@@ -1,5 +0,0 @@
-package goext
-
-const GoextVersion = "0.0.558"
-
-const GoextVersionTimestamp = "2025-01-10T15:36:23+0100"

gojson/README.md

@@ -1,15 +0,0 @@
-
-
-JSON serializer which serializes nil-Arrays as `[]` and nil-maps als `{}`.
-
-Idea from: https://github.com/homelight/json
-
-Forked from https://github.com/golang/go/tree/194de8fbfaf4c3ed54e1a3c1b14fc67a830b8d95/src/encoding/json ( tag go1.23.4 )
-  -> https://github.com/golang/go/tree/go1.23.4/src/encoding/json
-
-Added:
-
- - `MarshalSafeCollections()` method
- - `Encoder.nilSafeSlices` and `Encoder.nilSafeMaps` fields
- - `Add 'tagkey' to use different key than json (set on Decoder struct)`
- - `Add 'jsonfilter' to filter printed fields (set via MarshalSafeCollections)`

gojson/example_marshaling_test.go

@@ -1,73 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json_test
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"strings"
-)
-
-type Animal int
-
-const (
-	Unknown Animal = iota
-	Gopher
-	Zebra
-)
-
-func (a *Animal) UnmarshalJSON(b []byte) error {
-	var s string
-	if err := json.Unmarshal(b, &s); err != nil {
-		return err
-	}
-	switch strings.ToLower(s) {
-	default:
-		*a = Unknown
-	case "gopher":
-		*a = Gopher
-	case "zebra":
-		*a = Zebra
-	}
-
-	return nil
-}
-
-func (a Animal) MarshalJSON() ([]byte, error) {
-	var s string
-	switch a {
-	default:
-		s = "unknown"
-	case Gopher:
-		s = "gopher"
-	case Zebra:
-		s = "zebra"
-	}
-
-	return json.Marshal(s)
-}
-
-func Example_customMarshalJSON() {
-	blob := `["gopher","armadillo","zebra","unknown","gopher","bee","gopher","zebra"]`
-	var zoo []Animal
-	if err := json.Unmarshal([]byte(blob), &zoo); err != nil {
-		log.Fatal(err)
-	}
-
-	census := make(map[Animal]int)
-	for _, animal := range zoo {
-		census[animal] += 1
-	}
-
-	fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",
-		census[Gopher], census[Zebra], census[Unknown])
-
-	// Output:
-	// Zoo Census:
-	// * Gophers: 3
-	// * Zebras:  2
-	// * Unknown: 3
-}

gojson/example_test.go

@@ -1,310 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"strings"
-)
-
-func ExampleMarshal() {
-	type ColorGroup struct {
-		ID     int
-		Name   string
-		Colors []string
-	}
-	group := ColorGroup{
-		ID:     1,
-		Name:   "Reds",
-		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
-	}
-	b, err := json.Marshal(group)
-	if err != nil {
-		fmt.Println("error:", err)
-	}
-	os.Stdout.Write(b)
-	// Output:
-	// {"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
-}
-
-func ExampleUnmarshal() {
-	var jsonBlob = []byte(`[
-	{"Name": "Platypus", "Order": "Monotremata"},
-	{"Name": "Quoll",    "Order": "Dasyuromorphia"}
-]`)
-	type Animal struct {
-		Name  string
-		Order string
-	}
-	var animals []Animal
-	err := json.Unmarshal(jsonBlob, &animals)
-	if err != nil {
-		fmt.Println("error:", err)
-	}
-	fmt.Printf("%+v", animals)
-	// Output:
-	// [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
-}
-
-// This example uses a Decoder to decode a stream of distinct JSON values.
-func ExampleDecoder() {
-	const jsonStream = `
-	{"Name": "Ed", "Text": "Knock knock."}
-	{"Name": "Sam", "Text": "Who's there?"}
-	{"Name": "Ed", "Text": "Go fmt."}
-	{"Name": "Sam", "Text": "Go fmt who?"}
-	{"Name": "Ed", "Text": "Go fmt yourself!"}
-`
-	type Message struct {
-		Name, Text string
-	}
-	dec := json.NewDecoder(strings.NewReader(jsonStream))
-	for {
-		var m Message
-		if err := dec.Decode(&m); err == io.EOF {
-			break
-		} else if err != nil {
-			log.Fatal(err)
-		}
-		fmt.Printf("%s: %s\n", m.Name, m.Text)
-	}
-	// Output:
-	// Ed: Knock knock.
-	// Sam: Who's there?
-	// Ed: Go fmt.
-	// Sam: Go fmt who?
-	// Ed: Go fmt yourself!
-}
-
-// This example uses a Decoder to decode a stream of distinct JSON values.
-func ExampleDecoder_Token() {
-	const jsonStream = `
-	{"Message": "Hello", "Array": [1, 2, 3], "Null": null, "Number": 1.234}
-`
-	dec := json.NewDecoder(strings.NewReader(jsonStream))
-	for {
-		t, err := dec.Token()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			log.Fatal(err)
-		}
-		fmt.Printf("%T: %v", t, t)
-		if dec.More() {
-			fmt.Printf(" (more)")
-		}
-		fmt.Printf("\n")
-	}
-	// Output:
-	// json.Delim: { (more)
-	// string: Message (more)
-	// string: Hello (more)
-	// string: Array (more)
-	// json.Delim: [ (more)
-	// float64: 1 (more)
-	// float64: 2 (more)
-	// float64: 3
-	// json.Delim: ] (more)
-	// string: Null (more)
-	// <nil>: <nil> (more)
-	// string: Number (more)
-	// float64: 1.234
-	// json.Delim: }
-}
-
-// This example uses a Decoder to decode a streaming array of JSON objects.
-func ExampleDecoder_Decode_stream() {
-	const jsonStream = `
-	[
-		{"Name": "Ed", "Text": "Knock knock."},
-		{"Name": "Sam", "Text": "Who's there?"},
-		{"Name": "Ed", "Text": "Go fmt."},
-		{"Name": "Sam", "Text": "Go fmt who?"},
-		{"Name": "Ed", "Text": "Go fmt yourself!"}
-	]
-`
-	type Message struct {
-		Name, Text string
-	}
-	dec := json.NewDecoder(strings.NewReader(jsonStream))
-
-	// read open bracket
-	t, err := dec.Token()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("%T: %v\n", t, t)
-
-	// while the array contains values
-	for dec.More() {
-		var m Message
-		// decode an array value (Message)
-		err := dec.Decode(&m)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		fmt.Printf("%v: %v\n", m.Name, m.Text)
-	}
-
-	// read closing bracket
-	t, err = dec.Token()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("%T: %v\n", t, t)
-
-	// Output:
-	// json.Delim: [
-	// Ed: Knock knock.
-	// Sam: Who's there?
-	// Ed: Go fmt.
-	// Sam: Go fmt who?
-	// Ed: Go fmt yourself!
-	// json.Delim: ]
-}
-
-// This example uses RawMessage to delay parsing part of a JSON message.
-func ExampleRawMessage_unmarshal() {
-	type Color struct {
-		Space string
-		Point json.RawMessage // delay parsing until we know the color space
-	}
-	type RGB struct {
-		R uint8
-		G uint8
-		B uint8
-	}
-	type YCbCr struct {
-		Y  uint8
-		Cb int8
-		Cr int8
-	}
-
-	var j = []byte(`[
-	{"Space": "YCbCr", "Point": {"Y": 255, "Cb": 0, "Cr": -10}},
-	{"Space": "RGB",   "Point": {"R": 98, "G": 218, "B": 255}}
-]`)
-	var colors []Color
-	err := json.Unmarshal(j, &colors)
-	if err != nil {
-		log.Fatalln("error:", err)
-	}
-
-	for _, c := range colors {
-		var dst any
-		switch c.Space {
-		case "RGB":
-			dst = new(RGB)
-		case "YCbCr":
-			dst = new(YCbCr)
-		}
-		err := json.Unmarshal(c.Point, dst)
-		if err != nil {
-			log.Fatalln("error:", err)
-		}
-		fmt.Println(c.Space, dst)
-	}
-	// Output:
-	// YCbCr &{255 0 -10}
-	// RGB &{98 218 255}
-}
-
-// This example uses RawMessage to use a precomputed JSON during marshal.
-func ExampleRawMessage_marshal() {
-	h := json.RawMessage(`{"precomputed": true}`)
-
-	c := struct {
-		Header *json.RawMessage `json:"header"`
-		Body   string           `json:"body"`
-	}{Header: &h, Body: "Hello Gophers!"}
-
-	b, err := json.MarshalIndent(&c, "", "\t")
-	if err != nil {
-		fmt.Println("error:", err)
-	}
-	os.Stdout.Write(b)
-
-	// Output:
-	// {
-	// 	"header": {
-	// 		"precomputed": true
-	// 	},
-	// 	"body": "Hello Gophers!"
-	// }
-}
-
-func ExampleIndent() {
-	type Road struct {
-		Name   string
-		Number int
-	}
-	roads := []Road{
-		{"Diamond Fork", 29},
-		{"Sheep Creek", 51},
-	}
-
-	b, err := json.Marshal(roads)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var out bytes.Buffer
-	json.Indent(&out, b, "=", "\t")
-	out.WriteTo(os.Stdout)
-	// Output:
-	// [
-	// =	{
-	// =		"Name": "Diamond Fork",
-	// =		"Number": 29
-	// =	},
-	// =	{
-	// =		"Name": "Sheep Creek",
-	// =		"Number": 51
-	// =	}
-	// =]
-}
-
-func ExampleMarshalIndent() {
-	data := map[string]int{
-		"a": 1,
-		"b": 2,
-	}
-
-	b, err := json.MarshalIndent(data, "<prefix>", "<indent>")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Println(string(b))
-	// Output:
-	// {
-	// <prefix><indent>"a": 1,
-	// <prefix><indent>"b": 2
-	// <prefix>}
-}
-
-func ExampleValid() {
-	goodJSON := `{"example": 1}`
-	badJSON := `{"example":2:]}}`
-
-	fmt.Println(json.Valid([]byte(goodJSON)), json.Valid([]byte(badJSON)))
-	// Output:
-	// true false
-}
-
-func ExampleHTMLEscape() {
-	var out bytes.Buffer
-	json.HTMLEscape(&out, []byte(`{"Name":"<b>HTML content</b>"}`))
-	out.WriteTo(os.Stdout)
-	// Output:
-	//{"Name":"\u003cb\u003eHTML content\u003c/b\u003e"}
-}