first commit

Author: tkdeng

.gitignore

@@ -0,0 +1,4 @@
+.git
+.svn
+.vscode
+.idea

LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2025 web@tkdeng.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

buffer.go

@@ -0,0 +1,131 @@
+package regex
+
+import (
+	"bytes"
+	"errors"
+	"math/rand"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestCompile(t *testing.T) {
+	reC := Comp("this is test %1", "a")
+	if reC.RE.ReplaceAllString(`this is test a`, `this is test b`) != `this is test b` {
+		t.Error(`[this is test %1] [a]`, "\n", errors.New("failed to compile params"))
+	}
+
+	re := `test .*`
+	reEscaped := Escape(re)
+	if re == reEscaped || Comp(reEscaped).Match([]byte(`test 1`)) {
+		t.Error("[", reEscaped, "]\n", errors.New("escape function failed"))
+	}
+
+	r := Comp(`test %1`, "%2", "a")
+	if r.Match([]byte(`test a`)) {
+		t.Error(`[test %1] [%2, a]`, "\n", errors.New("escape function failed to escape '%' char"))
+	}
+}
+
+func TestReplaceStr(t *testing.T) {
+	var check = func(s string, re, r string, e string) {
+		res := Comp(re).RepLit([]byte(s), []byte(r))
+		if !bytes.Equal(res, []byte(e)) {
+			t.Error("[", string(res), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check("this is a test", `(?#a\s+)test`, "", "this is a ")
+	check("string with `block` quotes", `\'.*?\'`, "'single'", "string with 'single' quotes")
+}
+
+func TestReplaceStrComplex(t *testing.T) {
+	var check = func(s string, re, r string, e string) {
+		res := Comp(re).Rep([]byte(s), []byte(r))
+		if !bytes.Equal(res, []byte(e)) {
+			t.Error("[", string(res), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check("this is a Test", `(?i)a (test)`, "some $1", "this is some Test")
+	check("I Need Coffee!!!", `Coffee(!*)`, "More Coffee$1", "I Need More Coffee!!!")
+}
+
+func TestReplaceFunc(t *testing.T) {
+	var check = func(s string, re, r string, e string) {
+		res := Comp(re).RepFunc([]byte(s), func(data func(int) []byte) []byte {
+			return JoinBytes(data(1), ' ', r)
+		})
+		if !bytes.Equal(res, []byte(e)) {
+			t.Error("[", string(res), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check("this is a new test", `(new) test`, "pizza", "this is a new pizza")
+	check("a random string", `(a) random`, "not so random", "a not so random string")
+}
+
+func TestConcurrent(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		for j := 0; j < 10; j++ {
+			go (func() {
+				res := Comp(`(t)`).RepFunc([]byte("test"), func(data func(int) []byte) []byte {
+					return data(1)
+				})
+				_ = res
+				time.Sleep(10 * time.Nanosecond)
+			})()
+		}
+
+		// time.Sleep(1000000 * 1000) // 1 second
+		time.Sleep(1000000 * 100) // 0.1 second
+	}
+}
+
+func TestCache(t *testing.T) {
+	var check = func(s string, re, r string, e string) {
+		res := Comp(re).RepLit([]byte(s), []byte(r))
+		if !bytes.Equal(res, []byte(e)) {
+			t.Error("[", string(res), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check("this is a test", `\sis\s`, " was ", "this was a test")
+	check("this is a test", `\sis\s`, " was ", "this was a test")
+}
+
+func TestFlags(t *testing.T) {
+	var check = func(s string, re, r string, e string) {
+		res := Comp(re).RepLit([]byte(s), []byte(r))
+		if !bytes.Equal(res, []byte(e)) {
+			t.Error("[", string(res), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check("this is a\nmultiline text", `(?s)a\s*multiline`, "", "this is  text")
+	check("list line 1\nlist line 2\n list line 3", `(?m)^list`, "a list", "a list line 1\na list line 2\n list line 3")
+	check("a MultiCase text", `(?i)multicase`, "", "a  text")
+	check("a MultiCase text no flag", `multicase`, "", "a MultiCase text no flag")
+
+	// check("a multi\nline text", `multi\s*line`, "", "a multi\nline text")
+}
+
+func TestPerformance(t *testing.T) {
+	for i := 0; i < 10000; i++ {
+		Comp(strconv.Itoa(rand.Int()))
+	}
+}
+
+func TestValid(t *testing.T) {
+	var check = func(re string, e bool) {
+		res := IsValid(re)
+		if res != e {
+			t.Error("[", string(re), "]\n", errors.New("result does not match expected result"))
+		}
+	}
+
+	check(`[\w_\-]+`, true)
+	check(`[\w_-.]+`, false)
+	check(`(?<test>)`, true)
+	check(`(?i)test`, true)
+}

common/cache.go

@@ -0,0 +1,81 @@
+package common
+
+import (
+	"sync"
+	"time"
+)
+
+type CacheMap[T any] struct {
+	value map[string]T
+	err map[string]error
+	lastUse map[string]time.Time
+	mu sync.Mutex
+	null T
+}
+
+func NewCache[T any]() CacheMap[T] {
+	return CacheMap[T]{
+		value: map[string]T{},
+		err: map[string]error{},
+		lastUse: map[string]time.Time{},
+	}
+}
+
+// get returns a value or an error if it exists
+//
+// if the object key does not exist, it will return both a nil/zero value (of the relevant type) and nil error
+func (cache *CacheMap[T]) Get(key string) (T, error) {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	if err, ok := cache.err[key]; ok {
+		cache.lastUse[key] = time.Now()
+		return cache.null, err
+	}else if val, ok := cache.value[key]; ok {
+		cache.lastUse[key] = time.Now()
+		return val, nil
+	}
+
+	return cache.null, nil
+}
+
+// set sets or adds a new key with either a value, or an error
+func (cache *CacheMap[T]) Set(key string, value T, err error) {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	if err != nil {
+		cache.err[key] = err
+		delete(cache.value, key)
+		cache.lastUse[key] = time.Now()
+	}else{
+		cache.value[key] = value
+		delete(cache.err, key)
+		cache.lastUse[key] = time.Now()
+	}
+}
+
+// delOld removes old cache items
+func (cache *CacheMap[T]) DelOld(cacheTime time.Duration){
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
+	if cacheTime == 0 {
+		for key := range cache.lastUse {
+			delete(cache.value, key)
+			delete(cache.err, key)
+			delete(cache.lastUse, key)
+		}
+		return
+	}
+
+	now := time.Now().UnixNano()
+
+	for key, lastUse := range cache.lastUse {
+		if now - lastUse.UnixNano() > int64(cacheTime) {
+			delete(cache.value, key)
+			delete(cache.err, key)
+			delete(cache.lastUse, key)
+		}
+	}
+}

common/common.go

@@ -0,0 +1,29 @@
+package common
+
+import (
+	"math"
+	"syscall"
+)
+
+// JoinBytes is an easy way to join multiple values into a single []byte
+func JoinBytes(bytes ...any) []byte {
+	res := []byte{}
+	for _, b := range bytes {
+		res = append(res, ToString[[]byte](b)...)
+	}
+	return res
+}
+
+// SysFreeMemory returns the amount of memory available in megabytes
+func SysFreeMemory() float64 {
+	in := &syscall.Sysinfo_t{}
+	err := syscall.Sysinfo(in)
+	if err != nil {
+		return 0
+	}
+
+	// If this is a 32-bit system, then these fields are
+	// uint32 instead of uint64.
+	// So we always convert to uint64 to match signature.
+	return math.Round(float64(uint64(in.Freeram) * uint64(in.Unit)) / 1024 / 1024 * 100) / 100
+}