File size: 2,942 Bytes
619f93d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | package utils
import (
"net/url"
stdpath "path"
"strings"
"github.com/OpenListTeam/OpenList/v4/internal/errs"
)
// FixAndCleanPath
// The upper layer of the root directory is still the root directory.
// So ".." And "." will be cleared
// for example
// 1. ".." or "." => "/"
// 2. "../..." or "./..." => "/..."
// 3. "../.x." or "./.x." => "/.x."
// 4. "x//\\y" = > "/z/x"
func FixAndCleanPath(path string) string {
path = strings.ReplaceAll(path, "\\", "/")
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
return stdpath.Clean(path)
}
// PathAddSeparatorSuffix Add path '/' suffix
// for example /root => /root/
func PathAddSeparatorSuffix(path string) string {
if !strings.HasSuffix(path, "/") {
path = path + "/"
}
return path
}
// PathEqual judge path is equal
func PathEqual(path1, path2 string) bool {
return FixAndCleanPath(path1) == FixAndCleanPath(path2)
}
func IsSubPath(path string, subPath string) bool {
path, subPath = FixAndCleanPath(path), FixAndCleanPath(subPath)
return path == subPath || strings.HasPrefix(subPath, PathAddSeparatorSuffix(path))
}
func Ext(path string) string {
return strings.ToLower(SourceExt(path))
}
func SourceExt(path string) string {
ext := stdpath.Ext(path)
if len(ext) > 0 && ext[0] == '.' {
ext = ext[1:]
}
return ext
}
func EncodePath(path string, all ...bool) string {
seg := strings.Split(path, "/")
toReplace := []struct {
Src string
Dst string
}{
{Src: "%", Dst: "%25"},
{"%", "%25"},
{"?", "%3F"},
{"#", "%23"},
}
for i := range seg {
if len(all) > 0 && all[0] {
seg[i] = url.PathEscape(seg[i])
} else {
for j := range toReplace {
seg[i] = strings.ReplaceAll(seg[i], toReplace[j].Src, toReplace[j].Dst)
}
}
}
return strings.Join(seg, "/")
}
func JoinBasePath(basePath, reqPath string) (string, error) {
isRelativePath := strings.Contains(reqPath, "..")
reqPath = FixAndCleanPath(reqPath)
if isRelativePath && !strings.Contains(reqPath, "..") {
return "", errs.RelativePath
}
return stdpath.Join(FixAndCleanPath(basePath), reqPath), nil
}
func GetFullPath(mountPath, path string) string {
return stdpath.Join(GetActualMountPath(mountPath), path)
}
// GetPathHierarchy generates a hierarchy of paths from the given path.
//
// Example:
// 1. "/" => {"/"}
// 2. "" => {"/"}
// 3. "/a/b/c" => {"/", "/a", "/a/b", "/a/b/c"}
// 4. "/a/b/c/d/e.txt" => {"/", "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/a/b/c/d/e.txt"}
// 5. "./a/b///c" => {"/", "/a", "/a/b", "/a/b/c"}
func GetPathHierarchy(path string) []string {
if path == "" || path == "/" {
return []string{"/"}
}
path = FixAndCleanPath(path)
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
hierarchy := []string{"/"}
parts := strings.Split(path, "/")
currentPath := ""
for _, part := range parts {
if part == "" {
continue
}
currentPath += "/" + part
hierarchy = append(hierarchy, currentPath)
}
return hierarchy
}
|