👔 update: basefn - add new func PanicErr and update PanicIf logic

basefn/basefn.go

@@ -1,15 +1,47 @@
 // Package basefn provide some no-dependents util functions
 package basefn
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 // Panicf format panic message use fmt.Sprintf
 func Panicf(format string, v ...any) {
 	panic(fmt.Sprintf(format, v...))
 }
 
-// PanicIf if error is not empty
-func PanicIf(err error) {
+// PanicIf if cond = true, panics with error message
+func PanicIf(cond bool, fmtAndArgs ...any) {
+	if cond {
+		panic(errors.New(formatWithArgs(fmtAndArgs)))
+	}
+}
+
+func formatWithArgs(fmtAndArgs []any) string {
+	ln := len(fmtAndArgs)
+	if ln == 0 {
+		return ""
+	}
+
+	first := fmtAndArgs[0]
+
+	if ln == 1 {
+		if msgAsStr, ok := first.(string); ok {
+			return msgAsStr
+		}
+		return fmt.Sprintf("%+v", first)
+	}
+
+	// is template string.
+	if tplStr, ok := first.(string); ok {
+		return fmt.Sprintf(tplStr, fmtAndArgs[1:]...)
+	}
+	return fmt.Sprint(fmtAndArgs...)
+}
+
+// PanicErr panics if error is not empty
+func PanicErr(err error) {
 	if err != nil {
 		panic(err)
 	}

basefn/basefn_test.go

@@ -9,23 +9,43 @@ import (
 )
 
 func TestPanicIf(t *testing.T) {
-	basefn.PanicIf(nil)
+	basefn.PanicIf(false, "")
+	assert.Panics(t, func() {
+		basefn.PanicIf(true, "a error msg")
+	})
+
+	assert.Panics(t, func() {
+		basefn.PanicIf(true)
+	})
+	assert.Panics(t, func() {
+		basefn.PanicIf(true, 234)
+	})
+	assert.Panics(t, func() {
+		basefn.PanicIf(true, 234, "abc")
+	})
 
 	assert.Panics(t, func() {
-		basefn.PanicIf(errors.New("a error"))
+		basefn.PanicIf(true, "a error %s", "msg")
+	})
+}
+
+func TestPanicErr(t *testing.T) {
+	basefn.PanicErr(nil)
+	assert.Panics(t, func() {
+		basefn.PanicErr(errors.New("a error"))
 	})
 }
 
 func TestPanicf(t *testing.T) {
 	basefn.MustOK(nil)
+	assert.Panics(t, func() {
+		basefn.Panicf("hi %s", "inhere")
+	})
 
 	assert.Eq(t, "hi", basefn.Must("hi", nil))
 	assert.Panics(t, func() {
 		basefn.Must("hi", errors.New("a error"))
 	})
-	assert.Panics(t, func() {
-		basefn.Panicf("hi %s", "inhere")
-	})
 	assert.Panics(t, func() {
 		basefn.MustOK(errors.New("a error"))
 	})

cflag/cflag.go

@@ -189,7 +189,7 @@ func (c *CFlags) BindArg(arg *FlagArg) {
 	arg.Index = len(c.bindArgs)
 
 	// check arg info
-	basefn.PanicIf(arg.check())
+	basefn.PanicErr(arg.check())
 
 	if _, ok := c.argNames[arg.Name]; ok {
 		basefn.Panicf("cflag: arg '%s' have been registered", arg.Name)

goutil.go

@@ -5,6 +5,7 @@ package goutil
 import (
 	"fmt"
 
+	"github.com/gookit/goutil/basefn"
 	"github.com/gookit/goutil/goinfo"
 	"github.com/gookit/goutil/structs"
 )
@@ -17,6 +18,11 @@ func Panicf(format string, v ...any) {
 	panic(fmt.Sprintf(format, v...))
 }
 
+// PanicIf if cond = true, panics with error message
+func PanicIf(cond bool, fmtAndArgs ...any) {
+	basefn.PanicIf(cond, fmtAndArgs...)
+}
+
 // PanicIfErr if error is not empty, will panic
 func PanicIfErr(err error) {
 	if err != nil {

goutil_test.go

@@ -27,9 +27,25 @@ func TestPkgName(t *testing.T) {
 }
 
 func TestPanicIfErr(t *testing.T) {
+	goutil.PanicIf(false, "")
+	assert.Panics(t, func() {
+		goutil.PanicIf(true, "a error msg")
+	})
+
 	goutil.PanicIfErr(nil)
+	assert.Panics(t, func() {
+		goutil.PanicIfErr(errors.New("a error"))
+	})
+
 	goutil.PanicErr(nil)
+	assert.Panics(t, func() {
+		goutil.PanicErr(errors.New("a error"))
+	})
+
 	goutil.MustOK(nil)
+	assert.Panics(t, func() {
+		goutil.MustOK(errors.New("a error"))
+	})
 
 	assert.Eq(t, "hi", goutil.Must("hi", nil))
 	assert.Panics(t, func() {