104 lines
3.0 KiB
Go
104 lines
3.0 KiB
Go
package utils
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
|
|
logger "git.site.quack-lab.dev/dave/cylogger"
|
|
)
|
|
|
|
// pathLogger is a scoped logger for the utils/path package.
|
|
var pathLogger = logger.Default.WithPrefix("utils/path")
|
|
|
|
// ResolvePath resolves a file path by:
|
|
// 1. Expanding ~ to the user's home directory
|
|
// 2. Making the path absolute if it's relative
|
|
// 3. Normalizing path separators to forward slashes
|
|
// 4. Cleaning the path
|
|
func ResolvePath(path string) string {
|
|
resolvePathLogger := pathLogger.WithPrefix("ResolvePath").WithField("inputPath", path)
|
|
resolvePathLogger.Debug("Resolving path")
|
|
|
|
if path == "" {
|
|
resolvePathLogger.Warning("Empty path provided")
|
|
return ""
|
|
}
|
|
|
|
// Step 1: Expand ~ to home directory
|
|
originalPath := path
|
|
if strings.HasPrefix(path, "~") {
|
|
home := os.Getenv("HOME")
|
|
if home == "" {
|
|
// Fallback for Windows
|
|
if runtime.GOOS == "windows" {
|
|
home = os.Getenv("USERPROFILE")
|
|
}
|
|
}
|
|
if home != "" {
|
|
if path == "~" {
|
|
path = home
|
|
} else if strings.HasPrefix(path, "~/") {
|
|
path = filepath.Join(home, path[2:])
|
|
} else {
|
|
// Handle cases like ~username
|
|
// For now, just replace ~ with home directory
|
|
path = strings.Replace(path, "~", home, 1)
|
|
}
|
|
resolvePathLogger.Debug("Expanded tilde to home directory: home=%s, result=%s", home, path)
|
|
} else {
|
|
resolvePathLogger.Warning("Could not determine home directory for tilde expansion")
|
|
}
|
|
}
|
|
|
|
// Step 2: Make path absolute if it's not already
|
|
if !filepath.IsAbs(path) {
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
resolvePathLogger.Error("Failed to get current working directory: %v", err)
|
|
return path // Return as-is if we can't get CWD
|
|
}
|
|
path = filepath.Join(cwd, path)
|
|
resolvePathLogger.Debug("Made relative path absolute: cwd=%s, result=%s", cwd, path)
|
|
}
|
|
|
|
// Step 3: Clean the path
|
|
path = filepath.Clean(path)
|
|
resolvePathLogger.Debug("Cleaned path: result=%s", path)
|
|
|
|
// Step 4: Normalize path separators to forward slashes for consistency
|
|
path = strings.ReplaceAll(path, "\\", "/")
|
|
|
|
resolvePathLogger.Debug("Final resolved path: original=%s, final=%s", originalPath, path)
|
|
return path
|
|
}
|
|
|
|
// ResolvePathForLogging is the same as ResolvePath but includes more detailed logging
|
|
// for debugging purposes
|
|
func ResolvePathForLogging(path string) string {
|
|
return ResolvePath(path)
|
|
}
|
|
|
|
// IsAbsolutePath checks if a path is absolute (including tilde expansion)
|
|
func IsAbsolutePath(path string) bool {
|
|
// Check for tilde expansion first
|
|
if strings.HasPrefix(path, "~") {
|
|
return true // Tilde paths become absolute after expansion
|
|
}
|
|
return filepath.IsAbs(path)
|
|
}
|
|
|
|
// GetRelativePath returns the relative path from base to target
|
|
func GetRelativePath(base, target string) (string, error) {
|
|
resolvedBase := ResolvePath(base)
|
|
resolvedTarget := ResolvePath(target)
|
|
|
|
relPath, err := filepath.Rel(resolvedBase, resolvedTarget)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Normalize to forward slashes
|
|
return strings.ReplaceAll(relPath, "\\", "/"), nil
|
|
} |