remove test_src directory

* add fileutil.CopyDir

* remove debug code

docs/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -162,6 +163,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>拷贝文件夹到目标路径，会递归复制文件夹下所有的文件及文件夹，并且访问权限也与源文件夹保持一致。当dstPath存在时会返回error</p>
+
+<b>函数签名:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>返回当前位置的绝对路径。</p>

docs/en/api/packages/fileutil.md

@@ -26,6 +26,7 @@ import (
 -   [CreateFile](#CreateFile)
 -   [CreateDir](#CreateDir)
 -   [CopyFile](#CopyFile)
+-   [CopyDir](#CopyDir)
 -   [CurrentPath](#CurrentPath)
 -   [FileMode](#FileMode)
 -   [MiMeType](#MiMeType)
@@ -162,6 +163,34 @@ func main() {
 }
 ```
 
+### <span id="CopyDir">CopyDir</span>
+
+<p>copy	src directory to dst directory, it will copy all files and directories recursively. the access permission will be the same as the source directory. if dstPath exists, it will return an error.</p>
+
+<b>Signature:</b>
+
+```go
+func CopyDir(srcPath string, dstPath string) error
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YAyFTA_UuPb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    err := fileutil.CopyFile("./test_src", "./test_dest")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
 ### <span id="CurrentPath">CurrentPath</span>
 
 <p>return current absolute path.</p>

fileutil/file.go

@@ -113,6 +113,65 @@ func CreateDir(absPath string) error {
 	return os.MkdirAll(absPath, os.ModePerm)
 }
 
+// CopyDir copy	src directory to dst directory, it will copy all files and directories recursively.
+// the access permission will be the same as the source directory.
+// if dstPath exists, it will return an error.
+// Play: https://go.dev/play/p/YAyFTA_UuPb
+func CopyDir(srcPath string, dstPath string) error {
+	if !IsDir(srcPath) {
+		return errors.New("source path is not a directory")
+	}
+	var err error
+	srcPath, err = filepath.Abs(srcPath)
+	if err != nil {
+		return err
+	}
+	if IsExist(dstPath) {
+		return errors.New("destination path already exists")
+	}
+	dstPath, err = filepath.Abs(dstPath)
+	if err != nil {
+		return err
+	}
+
+	// get srcPath's file info
+	srcFileInfo, err := os.Stat(srcPath)
+	if err != nil {
+		return err
+	}
+
+	// create dstPath with srcPath's mode
+	err = os.MkdirAll(dstPath, srcFileInfo.Mode())
+	if err != nil {
+		return err
+	}
+
+	err = filepath.Walk(srcPath, func(path string, info os.FileInfo, err error) error {
+		if srcPath == path {
+			return nil
+		}
+		curDstPath := filepath.Join(dstPath, filepath.Base(path))
+		if info.IsDir() {
+			err = CopyDir(path, curDstPath)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = CopyFile(path, curDstPath)
+			if err != nil {
+				return err
+			}
+			err = os.Chmod(curDstPath, info.Mode())
+			if err != nil {
+				return err
+			}
+		}
+		return err
+	})
+
+	return err
+}
+
 // IsDir checks if the path is directory or not.
 // Play: https://go.dev/play/p/WkVwEKqtOWk
 func IsDir(path string) bool {
@@ -377,7 +436,7 @@ func UnZip(zipFile string, destPath string) error {
 	defer zipReader.Close()
 
 	for _, f := range zipReader.File {
-		//issue#62: fix ZipSlip bug
+		// issue#62: fix ZipSlip bug
 		path, err := safeFilepathJoin(destPath, f.Name)
 		if err != nil {
 			return err

fileutil/file_test.go

@@ -3,6 +3,8 @@ package fileutil
 import (
 	"io"
 	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -544,3 +546,23 @@ func TestReadlineFile(t *testing.T) {
 		internal.NewAssert(t, "TestReadlineFile").Equal(line, lineRead)
 	}
 }
+
+func TestCopyDir(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCopyDir")
+
+	src := "./testdata"
+	dest := "./testdata_copy"
+
+	err := CopyDir(src, dest)
+	assert.IsNil(err)
+
+	assert.Equal(true, IsExist(dest))
+
+	filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+		destPath := strings.Replace(path, src, dest, 1)
+		assert.Equal(true, IsExist(destPath))
+		return nil
+	})
+
+	os.RemoveAll(dest)
+}

fileutil/testdata/test01/demo2.csv

@@ -0,0 +1 @@
+makj1

function/predicate.go

@@ -3,6 +3,9 @@ package function
 // And returns a composed predicate that represents the logical AND of a list of predicates.
 // It evaluates to true only if all predicates evaluate to true for the given value.
 func And[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
 	return func(value T) bool {
 		for _, predicate := range predicates {
 			if !predicate(value) {
@@ -23,6 +26,9 @@ func Negate[T any](predicate func(T) bool) func(T) bool {
 // Or returns a composed predicate that represents the logical OR of a list of predicates.
 // It evaluates to true if at least one of the predicates evaluates to true for the given value.
 func Or[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
 	return func(value T) bool {
 		for _, predicate := range predicates {
 			if predicate(value) {
@@ -36,6 +42,9 @@ func Or[T any](predicates ...func(T) bool) func(T) bool {
 // Nor returns a composed predicate that represents the logical NOR of a list of predicates.
 // It evaluates to true only if all predicates evaluate to false for the given value.
 func Nor[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
 	return func(value T) bool {
 		for _, predicate := range predicates {
 			if predicate(value) {
@@ -45,3 +54,22 @@ func Nor[T any](predicates ...func(T) bool) func(T) bool {
 		return true // Only returns true if all predicates evaluate to false
 	}
 }
+
+// Xnor returns a composed predicate that represents the logical XNOR of a list of predicates.
+// It evaluates to true only if all predicates evaluate to true or false for the given value.
+func Xnor[T any](predicates ...func(T) bool) func(T) bool {
+	if len(predicates) < 2 {
+		panic("programming error: predicates count must be at least 2")
+	}
+	return func(value T) bool {
+		trueCount := 0
+		for _, predicate := range predicates {
+			if predicate(value) {
+				trueCount++
+			}
+		}
+		// XNOR is true if either all predicates are true or all are false
+		// This is the same as saying trueCount is 0 (all false) or trueCount is len(predicates) (all true)
+		return trueCount == 0 || trueCount == len(predicates)
+	}
+}

function/predicate_example_test.go

@@ -73,6 +73,22 @@ func ExampleNor() {
 	// false
 }
 
+func ExampleXnor() {
+	isEven := func(i int) bool { return i%2 == 0 }
+	isPositive := func(i int) bool { return i > 0 }
+
+	match := Xnor(isEven, isPositive)
+
+	fmt.Println(match(2))
+	fmt.Println(match(-3))
+	fmt.Println(match(3))
+
+	// Output:
+	// true
+	// true
+	// false
+}
+
 // func ExamplePredicatesMix() {
 // 	a := Or(
 // 		func(s string) bool { return strings.ContainsAny(s, "0123456789") },

function/predicate_test.go

@@ -74,6 +74,21 @@ func TestPredicatesNorPure(t *testing.T) {
 	assert.ShouldBeFalse(match("0123456789"))
 }
 
+func TestPredicatesXnorPure(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestPredicatesXnorPure")
+
+	isEven := func(i int) bool { return i%2 == 0 }
+	isPositive := func(i int) bool { return i > 0 }
+
+	match := Xnor(isEven, isPositive)
+
+	assert.ShouldBeTrue(match(2))
+	assert.ShouldBeTrue(match(-3))
+	assert.ShouldBeFalse(match(3))
+}
+
 func TestPredicatesMix(t *testing.T) {
 	t.Parallel()
 
@@ -95,4 +110,7 @@ func TestPredicatesMix(t *testing.T) {
 
 	c = Nor(a, b)
 	assert.ShouldBeFalse(c("hello!"))
+
+	c = Xnor(a, b)
+	assert.ShouldBeTrue(c("hello!"))
 }