helper

package module
v1.6.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2025 License: GPL-3.0 Imports: 43 Imported by: 17

README

Defacto2 / helper

Go Reference Go Report Card

Helpers are general system functions used by the Defacto2 server software. See the reference documentation for usage and examples.

Documentation

Overview

Package helper has general and shared functions.

Index

Examples

Constants

View Source 
const (
	// Eraseline is an ANSI escape control to erase the active line of the terminal.
	Eraseline = "\x1b[2K"
	// Timeout is the HTTP client timeout.
	Timeout = 5 * time.Second
	// UserAgent to send with the HTTP request.
	UserAgent = "Defacto2 website (thanks!)"
)
View Source 
const (
	// WriteWriteRead is the file mode for read and write access.
	// The file owner and group has read and write access, and others have read access.
	WriteWriteRead   fs.FileMode = 0o664
	DSStore                      = ".DS_Store"       // DSStore is the macOS directory service store file.
	TempBase                     = "defacto2-server" // TempBase is the base subdirectory for temporary files.
	DirWriteReadRead             = 0o755             // Directory permissions.
)
View Source 
const (
	Chrs24 = 24
	Chrs25 = 25
	Chrs29 = 29
)
View Source 
const LoggerKey contextKey = "logger"

LoggerKey is the key used to store the logger in the context.

Deprecated: As of release v1.5.

Variables

View Source 
var (
	ErrDiffLength = errors.New("files are of different lengths")
	ErrDirPath    = errors.New("directory path is a file")
	ErrExistPath  = errors.New("path ready exists and will not overwrite")
	ErrFilePath   = errors.New("file path is a directory")
	ErrKey        = errors.New("could not generate a random session key")
	ErrOSFile     = errors.New("os file is nil")
	ErrNoDir      = errors.New("not a directory")
	ErrRead       = errors.New("could not read files")
)

Functions

func Add1 

func Add1(a any) int64

Add1 returns the value of a + 1. The type of a must be an integer type or the result is 0.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	num := helper.Add1(2)
	fmt.Println(num)
}

Output:

3

func Alpha09 added in v1.6.3 

func Alpha09(b []byte, i, n int) bool

Alpha09 returns true if the slice of bytes exclusively contains alphanumeric characters. Everything else including punctuation returns false. i is the index position and n is the number of bytes to match.

func ByteCount 

func ByteCount(b int64) string

ByteCount formats b as in a compact, human-readable unit of measure.

source, yourbasic

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.ByteCount(0))
	fmt.Println(helper.ByteCount(1024))
	fmt.Println(helper.ByteCount(1024 * 1024))
}

Output:

0B
1k
1M

func ByteCountFloat 

func ByteCountFloat(b int64) string

ByteCountFloat formats b as in a human-readable unit of measure. Units measured in gigabytes or larger are returned with 1 decimal place.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.ByteCountFloat(1024 * 1024 * 1024))
}

Output:

1.1 GB

func Capitalize 

func Capitalize(s string) string

Capitalize returns a string with the first letter of the first word capitalized. If the first word is an acronym, it is capitalized as a word.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Capitalize("hello world"))
}

Output:

Hello world

func CfUUID 

func CfUUID(cfid string) (string, error)

CfUUID formats a 35 character, Coldfusion Universally Unique Identifier to a standard, 36 character, Universally Unique Identifier.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	newid, _ := helper.CfUUID("00000000-0000-0000-0000000000000000")
	fmt.Println(newid)
}

Output:

00000000-0000-0000-0000-000000000000

func ChrLast 

func ChrLast(s string) string

ChrLast returns the last character or rune of the string.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.ChrLast("hello"))
	fmt.Println(helper.ChrLast("abc\n"))
}

Output:

o
c

func CookieStore 

func CookieStore(envKey string) ([]byte, error)

CookieStore generates a key for use with the sessions cookie store middleware. envKey is the value of an imported environment session key. But if it is empty, a 32-bit randomized value is generated that changes on every restart.

The effect of using a randomized key will invalidate all existing sessions on every restart.

func Count 

func Count(dir string) (int, error)

Count returns the number of files in the given directory.

Example 
package main

import (
	"fmt"
	"path/filepath"

	"github.com/Defacto2/helper"
)

func main() {
	dir, _ := filepath.Abs("testdata")
	count, _ := helper.Count(dir)
	fmt.Printf("%v", count)
}

Output:

3

func Day 

func Day(i int) bool

Day returns true if the i value can be used as a day time value.

func DeObfuscate 

func DeObfuscate(s string) string

DeObfuscate the obfuscated string, or return the original string.

This function is a port of the deobfuscateParam function programmed in ColdFusion (CFML).

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.DeObfuscate("9b1c6"))
}

Output:

1

func DeleteDupe 

func DeleteDupe(s ...string) []string

DeleteDupe removes duplicate strings from a slice. The returned slice is sorted and compacted.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.DeleteDupe("b", "a", "a"))
}

Output:

[a b]

func DeobfuscateID 

func DeobfuscateID(id string) int

DeobfuscateID an obfuscated ID to return the primary key of the record. Returns a 0 if the id is not valid.

func DeobfuscateURL 

func DeobfuscateURL(rawURL string) int

DeobfuscateURL deobfuscate an obfuscated record URL to return a record's primary key. A URL can point to a Defacto2 record download or detail page. Returns a 0 if the URL is not valid.

func Determine 

func Determine(r io.Reader) encoding.Encoding

Determine returns the encoding of the plain text byte slice, either the charmap.ISO8859_1 or charmap.CodePage437 encoding is returned.

Without false-positives, is difficult to determine the encoding of a text slice without a BOM or other metadata, especially a legacy, 8-bit code page encoding vs UTF-8 encoding. For example, the 👾 (alien monster) emoji in UTF-8 is comprised of the bytes 240, 159, 145, 190, which are all valid CP-437 characters. 

"👾"	// [240 159 145 190] unicode.UTF8
"👾"	// [240 159 145 190] charmap.CodePage437
Example 
package main

import (
	"fmt"
	"strings"

	"github.com/Defacto2/helper"
)

func main() {
	a := strings.NewReader("hello")
	fmt.Println(helper.Determine(a))
}

Output:

ISO 8859-1

func DetermineS added in v1.5.2 

func DetermineS(sl *slog.Logger, r io.Reader) encoding.Encoding

DetermineS functions the same as Determine, however you can provide a slog logger to track character or sequence matches for false-positive discoveries and other possible problems.

func Digits added in v1.6.3 

func Digits(b []byte, i, n int) bool

Digits returns true if the slice of bytes is a sequence of digits. i is the index position and n is the number of bytes to match.

func DiskStat added in v1.6.5 

func DiskStat(path string) (float64, float64, float64, string, error)

DiskStat returns the total, free, and percentage free of the drive path. If no path is provided then the drive of the working directory is used.

The returned string is a humanized percentage, ie "50%".

func DiskUsage 

func DiskUsage(path string) (int64, error)

DiskUsage returns the total size of the files in the given directory.

Example 
package main

import (
	"fmt"
	"path/filepath"

	"github.com/Defacto2/helper"
)

func main() {
	dir, _ := filepath.Abs("testdata")
	du, _ := helper.DiskUsage(dir)
	fmt.Printf("%v", du)
}

Output:

755105

func Duplicate 

func Duplicate(oldpath, newpath string) (int64, error)

Duplicate is a workaround for renaming files across different devices. A cross device can also be a different file system such as a Docker volume. It returns the number of bytes written to the new file. The function returns an error if the newpath already exists.

func DuplicateOW 

func DuplicateOW(oldpath, newpath string) (int64, error)

DuplicateOW is a workaround for renaming files across different devices. A cross device can also be a different file system such as a Docker volume. It returns the number of bytes written to the new file. The function will truncate and overwrite the newpath if it already exists.

func Duplicater added in v1.4.0 

func Duplicater(r *os.Root, name, newname string) (int64, error)

Duplicater copies the contents of the named file to a new named file with the root. The function returns an error if the newpath already exists.

func DuplicaterOW added in v1.4.0 

func DuplicaterOW(r *os.Root, name, newname string) (int64, error)

DuplicaterOW copies the contents of the named file to a new file with the root. The function will truncate and overwrite the newpath if it already exists.

func File 

func File(name string) bool

File returns true if the named file exists on the system.

func FileMatch 

func FileMatch(name1, name2 string) (bool, error)

FileMatch returns true if the two named files are the same. It returns false if the files are of different lengths or if an error occurs while reading the files. The read buffer size is 4096 bytes.

func FileMatchR added in v1.4.0 

func FileMatchR(r *os.Root, name1, name2 string) (bool, error)

FileMatchR returns true if the two named files are the same. It returns false if the files are of different lengths or if an error occurs while reading the files. The read buffer size is 4096 bytes.

func Files 

func Files(dir string) ([]string, error)

Files returns the filenames in the given directory.

Example 
package main

import (
	"fmt"
	"path/filepath"

	"github.com/Defacto2/helper"
)

func main() {
	dir, _ := filepath.Abs("testdata")
	files, _ := helper.Files(dir)
	fmt.Printf("%v", files)
}

Output:

[PKZ80A1.TXT TEST.BMP TEST.DOC]

func Finds 

func Finds(name string, names ...string) bool

Finds returns true if the name is found in the collection of names.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Finds("bravo", "alfa", "bravo", "charlie", "delta"))
	fmt.Println(helper.Finds("bravo", "alfa", "charlie", "delta"))
}

Output:

true
false

func FmtSlice 

func FmtSlice(s string) string

FmtSlice formats a comma separated string.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.FmtSlice("alfa,bravo,charlie"))
}

Output:

Alfa, Bravo, Charlie

func IndexTerm added in v1.6.3 

func IndexTerm(i int, p []byte) int

IndexTerm searches the p byte array for a predefined list of words and combinations. Any matches will return the location index of the match. If no matches are found a 0 is returned.

The predefined list are items that can trigger online bots.

func Integrity 

func Integrity(name string, fs embed.FS) (string, error)

Integrity returns the sha384 hash of the named embed file. This is intended to be used for Subresource Integrity (SRI) verification with integrity attributes in HTML script and link tags.

func IntegrityBytes 

func IntegrityBytes(b []byte) string

IntegrityBytes returns the sha384 hash of the given byte slice.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.IntegrityBytes([]byte("hello")))
}

Output:

sha384-WeF0h3dEjGnea4ANejO7+5/xtGPkQ1TDVTvNucZm+pASWjx5+QOXvfX2oT3oKGhP

func IntegrityFile 

func IntegrityFile(name string) (string, error)

IntegrityFile returns the sha384 hash of the named file. This can be used as a link cache buster.

func Latency 

func Latency() *time.Time

Latency returns the stored, current local time.

func Lines 

func Lines(name string) (int, error)

Lines returns the number of lines in the named file.

Example 
package main

import (
	"fmt"
	"path/filepath"

	"github.com/Defacto2/helper"
)

func main() {
	name, _ := filepath.Abs(filepath.Join("testdata", "PKZ80A1.TXT"))
	lines, _ := helper.Lines(name)
	fmt.Printf("%v", lines)
}

Output:

175

func LocalHostPing 

func LocalHostPing(uri string, proto string, port int) (int, int64, error)

LocalHostPing sends a HTTP GET request to the provided URI on the localhost and returns the status code and size of the response.

func LocalHosts 

func LocalHosts() ([]string, error)

LocalHosts returns a list of local hostnames.

func LocalIPs 

func LocalIPs() ([]net.IP, error)

LocalIPs returns a list of local IP addresses.

credit, gosamples

func Logger deprecated 

func Logger(_ context.Context) any

Logger returns the logger from the context. If the logger is not found, it panics.

Deprecated: As of release v1.5, this function returns nil.

func Mask added in v1.6.0 

func Mask(p ...byte) []byte

Mask runs a performant scan of the bytes and replaces any matching serials or key sequences with a sequence of 0 characters of the same length.

Currently the following patterns are matched

  • 12345-67890-ABCDE-FGHIJ-LMNOP
  • 1234-5678-ABCD-EFGH-IJKL-MNOP
  • 1234-567890A-BCDEFGH-IJKL
  • 1234 1240000 1234000 0000
  • 1234-5678-ABCD-EFGH-IJKL

In addition telephone numbers matching seven digit (or more) phone numbers will have two digits replaced by $$.

And finally, there's are collection words and combos that will be masked with xxx. For example, any occurrence of the word "password" will be masked as "pxxxxxx".

For example: "Hello world B014-56789A-BCDEFGH-G45X example".

Would be masked with: "Hello world 000000000000000000000000 example".

func MaskTerm added in v1.6.3 

func MaskTerm(p ...byte) []byte

MaskTerm replaces a predefined list of words and combinations with a series of x characters. For example, any occurrence of the word "password" will be masked as "pxxxxxx".

MaskTerm should not be used with Mask as it duplicates functionality.

func MaxLineLength 

func MaxLineLength(s string) int

MaxLineLength counts the character length of the longest line in a string.

Example 
package main

import (
	"fmt"
	"strings"

	"github.com/Defacto2/helper"
)

func main() {
	s := strings.Repeat("a", 100) + "\n" + strings.Repeat("b", 50)
	fmt.Println(helper.MaxLineLength(s))
}

Output:

100

func MkContent 

func MkContent(src string) (string, error)

MkContent returns the destination directory for the extracted archive content. The directory is created if it does not exist. The directory is named after the source file.

func NANP added in v1.6.3 

func NANP(i int, p []byte) bool

NANP matches an areacode and a 7 digit number, ie 305-555-1234. However, area codes below 200 are not matched, ie 199-555-1234.

func Obfuscate 

func Obfuscate(s string) string

Obfuscate a numeric string to insecurely hide database primary key values when passed along a URL.

This function is a port of the obfuscateParam function programmed in ColdFusion (CFML).

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Obfuscate("1"))
	fmt.Println(helper.Obfuscate("abc"))
}

Output:

9b1c6
abc

func ObfuscateID 

func ObfuscateID(key int64) string

ObfuscateID the primary key of a record as a string that is used as a URL param or path.

func Owner 

func Owner() ([]string, string, error)

Owner returns the running user and group of the web application. The function returns the group names and the username of the owner.

func PageCount 

func PageCount(sum, limit int) int

PageCount returns the maximum pages possible for the sum of records with a record limit per-page.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.PageCount(1000, 100))
}

Output:

10

func Phone added in v1.6.3 

func Phone(i int, p []byte) bool

Phone matches a 7 digit telephone number, ie "555-1234".

func Ping 

func Ping(uri string) (int, int64, error)

Ping sends a HTTP GET request to the provided URI and returns the status code and size of the response.

func Released 

func Released(s string) (int16, int16, int16)

Released returns a string release date as year, month, day int16 values. The string is expected to be in the format "2024-07-15" or "2024-07" or "2024".

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	year, month, day := helper.Released("2024-07-15")
	fmt.Println(year, month, day)
}

Output:

2024 7 15

func RenameCrossDevice 

func RenameCrossDevice(oldpath, newpath string) error

RenameCrossDevice is a workaround for renaming files across different devices. A cross device can also be a different file system such as a Docker volume.

func RenameFile 

func RenameFile(oldpath, newpath string) error

RenameFile renames a file from oldpath to newpath. It returns an error if the oldpath does not exist or is a directory, newpath already exists, or the rename fails.

func RenameFileOW 

func RenameFileOW(oldpath, newpath string) error

RenameFileOW renames a file from oldpath to newpath. It returns an error if the oldpath does not exist or is a directory or the rename fails.

func RenameRoot added in v1.4.0 

func RenameRoot(r *os.Root, oldname, newname string) error

RenameRoot renames a file from oldname to newname. It returns an error if the oldname does not exist or is a directory, newname already exists, or the rename fails.

func RenameRootOW added in v1.4.0 

func RenameRootOW(r *os.Root, oldname, newname string) error

RenameRootOW renames a file from oldname to newname. It returns an error if the oldname does not exist or is a directory or the rename fails.

func ReverseInt 

func ReverseInt(i int) (int, error)

ReverseInt reverses an integer.

credit, Wade73

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	i, _ := helper.ReverseInt(123456)
	fmt.Println(i)
}

Output:

654321

func SearchTerm 

func SearchTerm(input string) []string

SearchTerm returns a list of search terms from the input string. The input string is split by commas.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.SearchTerm("quick,brown,fox"))
}

Output:

[quick brown fox]

func ShortMonth 

func ShortMonth(month int) string

ShortMonth takes a month integer and abbreviates it to a three letter English month.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.ShortMonth(1))
}

Output:

Jan

func Size 

func Size(name string) int64

Size returns the size of the named file. If the file does not exist, it returns -1.

func Slug 

func Slug(name string) string

Slug returns a URL friendly string of the named group.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Slug("Hello World Homepage!"))
}

Output:

hello-world-homepage

func SortNames added in v1.4.1 

func SortNames(sep string, names []string) []string

SortNames sorts the names using the filepath separator, where the root files are preferred.

Usually the sep value is a forward slash (/) or a Windows backslash (\).

func SplitAsSpaces 

func SplitAsSpaces(s string) string

SplitAsSpaces splits a string at each capital letter.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.SplitAsSpaces("TheQuickBrownFox"))
}

Output:

The Quick Brown Fox

func Stat 

func Stat(name string) bool

Stat stats the named file or directory to confirm it exists on the system.

func StrongIntegrity 

func StrongIntegrity(name string) (string, error)

StrongIntegrity returns the SHA-386 checksum value of the named file.

func StrongIntegrityR added in v1.4.0 

func StrongIntegrityR(r *os.Root, name string) (string, error)

StrongIntegrityR returns the SHA-386 checksum value of the named file.

func Sum386 

func Sum386(f *os.File) (string, error)

Sum386 returns the SHA-386 checksum value of the open file.

func TimeDistance 

func TimeDistance(from, to time.Time, seconds bool) string

TimeDistance describes the difference between two time values. The seconds parameter determines if the string should handle less than a minute values.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Defacto2/helper"
)

func main() {
	oneMinuteAgo := time.Now().Add(-15 * time.Second)
	fmt.Println(helper.TimeDistance(oneMinuteAgo, time.Now(), true))
	fmt.Println(helper.TimeDistance(oneMinuteAgo, time.Now(), false))

	oneHourAgo := time.Now().Add(-time.Hour)
	fmt.Println(helper.TimeDistance(oneHourAgo, time.Now(), true))

	oneHourAhead := time.Now().Add(time.Hour)
	fmt.Println(helper.TimeDistance(oneHourAgo, oneHourAhead, true))
}

Output:

less than 20 seconds
less than a minute
about 1 hour
about 2 hours

func Titleize 

func Titleize(s string) string

Titleize returns a string with the first letter each word capitalized. If a word is an acronym, it is capitalized as a word.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Titleize("hello world"))
}

Output:

Hello World

func TmpDir 

func TmpDir() string

TmpDir returns the temporary directory for the server, which is a subdirectory of the system temp directory.

func Touch 

func Touch(name string) error

Touch creates a new, empty named file. If the file already exists, an error is returned.

func TouchR added in v1.4.0 

func TouchR(r *os.Root, name string) error

TouchR creates a new, empty named file. If the file already exists, an error is returned.

func TouchW 

func TouchW(name string, data ...byte) (int, error)

TouchW creates a new named file with the given data. If the file already exists, an error is returned.

func TouchWR added in v1.4.0 

func TouchWR(r *os.Root, name string, data ...byte) (int, error)

TouchWR creates a new named file with the given data. If the file already exists, an error is returned.

func TrimPunct 

func TrimPunct(s string) string

TrimPunct removes any trailing, common punctuation characters from the string.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.TrimPunct("OMG?!?"))
}

Output:

OMG

func TrimRoundBraket 

func TrimRoundBraket(s string) string

TrimRoundBraket removes the tailing round brakets and any whitespace.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.TrimRoundBraket("Hello (world)"))
}

Output:

Hello

func TruncFilename 

func TruncFilename(w int, name string) string

TruncFilename reduces a filename to the length of w characters. The file extension is always preserved with the truncation.

func UTF8 

func UTF8(name string) (bool, error)

UTF8 returns true if the named file is a valid UTF-8 encoded file. The function reads the first 512 bytes of the file to determine the encoding.

func Year 

func Year(i int) bool

Year returns true if the i value is greater than 1969 or equal to the current year.

func Years 

func Years(a, b int16) string

Years returns a string of the years if they are different. If they are the same, it returns a singular year.

Example 
package main

import (
	"fmt"

	"github.com/Defacto2/helper"
)

func main() {
	fmt.Println(helper.Years(1990, 2000))
	fmt.Println(helper.Years(1990, 1991))
	fmt.Println(helper.Years(1990, 1990))
}

Output:

the years 1990 - 2000
the years 1990 and 1991
the year 1990

Types

type Extension 

type Extension struct {
	Name  string // Name is the file extension.
	Count int64  // Count is the number of files with the extension.
}

Extension is a file extension with a count of files.

func CountExts 

func CountExts(dir string) ([]Extension, error)

CountExts returns the file extensions and the number of files in the given directory.

Example 
package main

import (
	"fmt"
	"path/filepath"

	"github.com/Defacto2/helper"
)

func main() {
	dir, _ := filepath.Abs("testdata")
	counts, _ := helper.CountExts(dir)
	fmt.Printf("%v", counts)
}

Output:

[{.bmp 1} {.doc 1} {.txt 1}]

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.