Merge pull request #33 from TheManticoreProject/improve-utils

[enhancement] Improve utils

Author: p0dalirius

utils/path.go

@@ -0,0 +1,45 @@
+package utils
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+// PathSafeString returns a string that is safe to use in file paths by replacing unsafe characters.
+//
+// Parameters:
+// - input: The input string to be sanitized.
+//
+// Returns:
+// - A string that is safe to use in file paths.
+func PathSafeString(input string) string {
+	unsafeChars := []string{"/", "\\", ":", "*", "?", "\"", "<", ">", "|", " ", "\n", "\r", "\t", "\v", "\f", "\b", " "}
+	safeString := input
+	for _, char := range unsafeChars {
+		safeString = strings.ReplaceAll(safeString, char, "_")
+	}
+	return safeString
+}
+
+// EnsureDirExists checks if a directory exists and creates it if it doesn't.
+// It uses os.MkdirAll, so it can create parent directories as needed.
+//
+// Parameters:
+// - dirPath: The path of the directory to ensure existence.
+//
+// Returns:
+// - An error if the directory could not be created or if there was an issue checking its existence.
+func EnsureDirExists(dirPath string) error {
+	info, err := os.Stat(dirPath)
+	if err == nil {
+		if info.IsDir() {
+			return nil
+		}
+		return fmt.Errorf("path exists and is not a directory: %s", dirPath)
+	}
+	if os.IsNotExist(err) {
+		return os.MkdirAll(dirPath, 0755) // 0755 is a common permission for directories
+	}
+	return err
+}

utils/path_test.go

@@ -0,0 +1,140 @@
+package utils_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/TheManticoreProject/Manticore/utils"
+)
+
+func TestPathSafeString(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "empty string",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "no unsafe characters",
+			input:    "safe_filename_123",
+			expected: "safe_filename_123",
+		},
+		{
+			name:     "common unsafe characters",
+			input:    "file/name\\with:bad*chars?\"<>|",
+			expected: "file_name_with_bad_chars_____",
+		},
+		{
+			name:     "whitespace characters",
+			input:    "file name\nwith\rspaces\t",
+			expected: "file_name_with_spaces_",
+		},
+		{
+			name:     "mixed safe and unsafe",
+			input:    "My Document (v1.0)/part_A.txt",
+			expected: "My_Document_(v1.0)_part_A.txt",
+		},
+		{
+			name:     "all unsafe characters",
+			input:    "/:*?\"<>| \n\r\t",
+			expected: "____________",
+		},
+		{
+			name:     "multiple occurrences of same unsafe char",
+			input:    "path//to\\file",
+			expected: "path__to_file",
+		},
+		{
+			name:     "leading/trailing unsafe chars",
+			input:    " /file.txt ",
+			expected: "__file.txt_",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := utils.PathSafeString(tt.input)
+			if got != tt.expected {
+				t.Errorf("PathSafeString(%q) = %q, want %q", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestEnsureDirExists(t *testing.T) {
+	baseTempDir := filepath.Join(os.TempDir(), "test_ensure_dir_exists")
+	// Ensure cleanup for all tests in this function
+	defer func() {
+		if err := os.RemoveAll(baseTempDir); err != nil {
+			t.Logf("Failed to clean up base temp directory %q: %v", baseTempDir, err)
+		}
+	}()
+
+	t.Run("directory does not exist", func(t *testing.T) {
+		dirPath := filepath.Join(baseTempDir, "new_dir")
+		// Ensure it doesn't exist before the test
+		_ = os.RemoveAll(dirPath)
+
+		err := utils.EnsureDirExists(dirPath)
+		if err != nil {
+			t.Fatalf("EnsureDirExists(%q) returned an error: %v", dirPath, err)
+		}
+
+		if _, err := os.Stat(dirPath); os.IsNotExist(err) {
+			t.Errorf("EnsureDirExists(%q) failed to create directory", dirPath)
+		}
+	})
+
+	t.Run("directory already exists", func(t *testing.T) {
+		dirPath := filepath.Join(baseTempDir, "existing_dir")
+		err := os.MkdirAll(dirPath, 0755)
+		if err != nil {
+			t.Fatalf("Failed to create pre-existing directory: %v", err)
+		}
+
+		err = utils.EnsureDirExists(dirPath)
+		if err != nil {
+			t.Errorf("EnsureDirExists(%q) returned an error for existing directory: %v", dirPath, err)
+		}
+	})
+
+	t.Run("nested directories", func(t *testing.T) {
+		dirPath := filepath.Join(baseTempDir, "parent", "child", "grandchild")
+		// Ensure parent doesn't exist before the test
+		_ = os.RemoveAll(filepath.Join(baseTempDir, "parent"))
+
+		err := utils.EnsureDirExists(dirPath)
+		if err != nil {
+			t.Fatalf("EnsureDirExists(%q) returned an error for nested directories: %v", dirPath, err)
+		}
+
+		if _, err := os.Stat(dirPath); os.IsNotExist(err) {
+			t.Errorf("EnsureDirExists(%q) failed to create nested directories", dirPath)
+		}
+	})
+
+	t.Run("path exists as file returns error", func(t *testing.T) {
+		filePath := filepath.Join(baseTempDir, "somefile")
+		// Ensure fresh base dir
+		_ = os.RemoveAll(baseTempDir)
+		if err := os.MkdirAll(baseTempDir, 0755); err != nil {
+			t.Fatalf("failed to create base temp dir: %v", err)
+		}
+		// Create a file at the path
+		f, err := os.Create(filePath)
+		if err != nil {
+			t.Fatalf("failed to create file for test: %v", err)
+		}
+		_ = f.Close()
+
+		err = utils.EnsureDirExists(filePath)
+		if err == nil {
+			t.Fatalf("EnsureDirExists(%q) did not return error when path is an existing file", filePath)
+		}
+	})
+}

utils/random.go

@@ -0,0 +1,95 @@
+package utils
+
+import (
+	crand "crypto/rand"
+	"math/big"
+	mrand "math/rand"
+)
+
+// RandomString generates a random string of the specified length.
+//
+// Parameters:
+// - length: The length of the random string to generate.
+//
+// Returns:
+// - A string of the specified length.
+func RandomString(length int) string {
+	if length <= 0 {
+		return ""
+	}
+	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+	b := make([]byte, length)
+	rangeSize := big.NewInt(int64(len(charset)))
+	for i := 0; i < length; i++ {
+		n, err := crand.Int(crand.Reader, rangeSize)
+		if err != nil {
+			b[i] = charset[mrand.Intn(len(charset))]
+			continue
+		}
+		b[i] = charset[n.Int64()]
+	}
+
+	return string(b)
+}
+
+// RandomInt generates a random integer between min (inclusive) and max (inclusive).
+//
+// Parameters:
+// - min: The minimum value (inclusive).
+// - max: The maximum value (inclusive).
+//
+// Returns:
+// - A random integer within the specified range.
+func RandomInt(min, max int) int {
+	if min > max {
+		min, max = max, min // Swap if min is greater than max
+	}
+	// Use int64 to avoid overflow when computing range size
+	a := int64(min)
+	b := int64(max)
+	rangeSize := b - a + 1
+	if rangeSize <= 0 {
+		// Overflow or invalid range; return min as a safe fallback
+		return min
+	}
+	r, err := crand.Int(crand.Reader, big.NewInt(rangeSize))
+	if err != nil {
+		// Fallback to math/rand if crypto/rand fails
+		return int(a + (mrand.Int63n(rangeSize)))
+	}
+	return int(a + r.Int64())
+}
+
+// RandomBytes generates a random byte slice of the specified length.
+//
+// Parameters:
+// - length: The length of the byte slice to generate.
+//
+// Returns:
+// - A byte slice filled with random data.
+func RandomBytes(length int) []byte {
+	if length <= 0 {
+		return []byte{}
+	}
+	b := make([]byte, length)
+	if _, err := crand.Read(b); err != nil {
+		// Fallback to non-crypto PRNG if crypto/rand fails
+		for i := range b {
+			b[i] = byte(mrand.Intn(256))
+		}
+	}
+	return b
+}
+
+// RandomBool generates a random boolean value.
+//
+// Returns:
+// - A random boolean (true or false).
+func RandomBool() bool {
+	var one [1]byte
+	if _, err := crand.Read(one[:]); err == nil {
+		return (one[0] & 1) == 0 // 50% chance for true, 50% for false
+	}
+	return mrand.Intn(2) == 0
+}