✨ feat: add new pkg: syncs and internal pkg: checkfn

check.go

@@ -3,8 +3,8 @@ package goutil
 import (
 	"reflect"
 
+	"github.com/gookit/goutil/internal/checkfn"
 	"github.com/gookit/goutil/reflects"
-	"github.com/gookit/goutil/stdutil"
 )
 
 // IsNil value check
@@ -58,7 +58,7 @@ func IsEqual(src, dst any) bool {
 //	string 	    - check sub-string exists
 //	array,slice - check sub-element exists
 func Contains(data, elem any) bool {
-	_, found := stdutil.CheckContains(data, elem)
+	_, found := checkfn.Contains(data, elem)
 	return found
 }
 
@@ -70,6 +70,6 @@ func Contains(data, elem any) bool {
 //	string 	    - check sub-string exists
 //	array,slice - check sub-element exists
 func IsContains(data, elem any) bool {
-	_, found := stdutil.CheckContains(data, elem)
+	_, found := checkfn.Contains(data, elem)
 	return found
 }

errorx/panics/assert.go

@@ -1,8 +1,8 @@
 package panics
 
 import (
+	"github.com/gookit/goutil/internal/checkfn"
 	"github.com/gookit/goutil/internal/comfunc"
-	"github.com/gookit/goutil/stdutil"
 )
 
 // IsTrue assert result is true, otherwise will panic
@@ -35,14 +35,14 @@ func NotNil(result any, fmtAndArgs ...any) {
 
 // IsEmpty assert result is empty, otherwise will panic
 func IsEmpty(result any, fmtAndArgs ...any) {
-	if !stdutil.IsEmpty(result) {
+	if !checkfn.IsEmpty(result) {
 		panicWithMsg("result should be empty", fmtAndArgs)
 	}
 }
 
 // NotEmpty assert result is empty, otherwise will panic
 func NotEmpty(result any, fmtAndArgs ...any) {
-	if stdutil.IsEmpty(result) {
+	if checkfn.IsEmpty(result) {
 		panicWithMsg("result should not be empty", fmtAndArgs)
 	}
 }

internal/TODO.md

@@ -0,0 +1,6 @@
+# TODO
+
+## new package
+
+- misc package 杂项
+- syncs package

internal/checkfn/check.go

@@ -0,0 +1,73 @@
+package checkfn
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/gookit/goutil/reflects"
+)
+
+// IsNil value check
+func IsNil(v any) bool {
+	if v == nil {
+		return true
+	}
+	return reflects.IsNil(reflect.ValueOf(v))
+}
+
+// IsEmpty value check
+func IsEmpty(v any) bool {
+	if v == nil {
+		return true
+	}
+	return reflects.IsEmpty(reflect.ValueOf(v))
+}
+
+// Contains try loop over the data check if the data includes the element.
+//
+// TIP: only support types: string, map, array, slice
+//
+//	map         - check key exists
+//	string 	    - check sub-string exists
+//	array,slice - check sub-element exists
+//
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func Contains(data, elem any) (valid, found bool) {
+	dataRv := reflect.ValueOf(data)
+	dataRt := reflect.TypeOf(data)
+	if dataRt == nil {
+		return false, false
+	}
+
+	dataKind := dataRt.Kind()
+
+	// string
+	if dataKind == reflect.String {
+		return true, strings.Contains(dataRv.String(), reflect.ValueOf(elem).String())
+	}
+
+	// map
+	if dataKind == reflect.Map {
+		mapKeys := dataRv.MapKeys()
+		for i := 0; i < len(mapKeys); i++ {
+			if reflects.IsEqual(mapKeys[i].Interface(), elem) {
+				return true, true
+			}
+		}
+		return true, false
+	}
+
+	// array, slice - other return false
+	if dataKind != reflect.Slice && dataKind != reflect.Array {
+		return false, false
+	}
+
+	for i := 0; i < dataRv.Len(); i++ {
+		if reflects.IsEqual(dataRv.Index(i).Interface(), elem) {
+			return true, true
+		}
+	}
+	return true, false
+}

internal/comfunc/README.md

@@ -0,0 +1,3 @@
+# common func for internal use
+
+- don't depend on other external packages

syncs/chan.go

@@ -0,0 +1,35 @@
+package syncs
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// WaitCloseSignals for some huang program.
+//
+// Usage:
+//
+//	// do something. eg: start a http server
+//
+//	syncs.WaitCloseSignals(func(sig os.Signal) {
+//		// do something
+//	})
+func WaitCloseSignals(onClose func(sig os.Signal)) {
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+
+	// block until a signal is received.
+	onClose(<-signals)
+}
+
+// Go is a basic promise implementation: it wraps calls a function in a goroutine
+// and returns a channel which will later return the function's return value.
+func Go(f func() error) error {
+	ch := make(chan error)
+	go func() {
+		ch <- f()
+	}()
+
+	return <-ch
+}

stdutil/chan_test.go → syncs/chan_test.go

@@ -1,14 +1,14 @@
-package stdutil_test
+package syncs_test
 
 import (
 	"testing"
 
-	"github.com/gookit/goutil/stdutil"
+	"github.com/gookit/goutil/syncs"
 	"github.com/gookit/goutil/testutil/assert"
 )
 
 func TestGo(t *testing.T) {
-	err := stdutil.Go(func() error {
+	err := syncs.Go(func() error {
 		return nil
 	})
 	assert.NoErr(t, err)

stdutil/chan.go → syncs/signal.go

@@ -1,34 +1,12 @@
-package stdutil
+package syncs
 
 import (
 	"context"
 	"fmt"
-	"io"
 	"os"
 	"os/signal"
-	"syscall"
 )
 
-// WaitCloseSignals for some huang program.
-func WaitCloseSignals(closer io.Closer) error {
-	signals := make(chan os.Signal, 1)
-	signal.Notify(signals, os.Interrupt, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
-	<-signals
-
-	return closer.Close()
-}
-
-// Go is a basic promise implementation: it wraps calls a function in a goroutine
-// and returns a channel which will later return the function's return value.
-func Go(f func() error) error {
-	ch := make(chan error)
-	go func() {
-		ch <- f()
-	}()
-
-	return <-ch
-}
-
 // SignalHandler returns an actor, i.e. an execute and interrupt func, that
 // terminates with SignalError when the process receives one of the provided
 // signals, or the parent context is canceled.

testutil/assert/asserts.go

@@ -9,15 +9,15 @@ import (
 
 	"github.com/gookit/color"
 	"github.com/gookit/goutil/arrutil"
+	"github.com/gookit/goutil/internal/checkfn"
 	"github.com/gookit/goutil/maputil"
 	"github.com/gookit/goutil/mathutil"
 	"github.com/gookit/goutil/reflects"
-	"github.com/gookit/goutil/stdutil"
 )
 
 // Nil asserts that the given is a nil value
 func Nil(t TestingT, give any, fmtAndArgs ...any) bool {
-	if stdutil.IsNil(give) {
+	if checkfn.IsNil(give) {
 		return true
 	}
 
@@ -27,7 +27,7 @@ func Nil(t TestingT, give any, fmtAndArgs ...any) bool {
 
 // NotNil asserts that the given is a not nil value
 func NotNil(t TestingT, give any, fmtAndArgs ...any) bool {
-	if !stdutil.IsNil(give) {
+	if !checkfn.IsNil(give) {
 		return true
 	}
 
@@ -175,7 +175,7 @@ func PanicsErrMsg(t TestingT, fn PanicRunFunc, errMsg string, fmtAndArgs ...any)
 //	string      - check sub-string exists
 //	array,slice - check sub-element exists
 func Contains(t TestingT, src, elem any, fmtAndArgs ...any) bool {
-	valid, found := stdutil.CheckContains(src, elem)
+	valid, found := checkfn.Contains(src, elem)
 	if valid && found {
 		return true
 	}
@@ -199,7 +199,7 @@ func Contains(t TestingT, src, elem any, fmtAndArgs ...any) bool {
 //	string      - check sub-string exists
 //	array,slice - check sub-element exists
 func NotContains(t TestingT, src, elem any, fmtAndArgs ...any) bool {
-	valid, found := stdutil.CheckContains(src, elem)
+	valid, found := checkfn.Contains(src, elem)
 	if valid && !found {
 		return true
 	}