feat(utils): add resolvepath function (#294)

Author: plastikfan

.vscode/settings.json

@@ -46,6 +46,7 @@
     "nolintlint",
     "onecontext",
     "prealloc",
+    "rabbitweed",
     "repath",
     "Resumer",
     "rxgo",
@@ -63,6 +64,7 @@
     "usao",
     "varcheck",
     "xname",
+    "xpander",
     "Zemlya",
     "Zeroable"
   ]

xfs/utils/resolve-path.go

@@ -0,0 +1,67 @@
+package utils
+
+import (
+	"os"
+	"path/filepath"
+)
+
+// AbsFunc signature of function used to obtain the absolute representation of
+// a path.
+type AbsFunc func(path string) (string, error)
+
+// Abs function invoker, allows a function to be used in place where
+// an instance of an interface would be expected.
+func (f AbsFunc) Abs(path string) (string, error) {
+	return f(path)
+}
+
+// HomeUserFunc signature of function used to obtain the user's home directory.
+type HomeUserFunc func() string
+
+// Home function invoker, allows a function to be used in place where
+// an instance of an interface would be expected.
+func (f HomeUserFunc) Home() string {
+	return f()
+}
+
+// ResolveOverrides, used to override the internal functions used
+// to resolve the home path (os.UserHomeDir) and the abs path
+// (filepath.Abs). In normal usage, these do not need to be overridden,
+// just used for testing purposes.
+type ResolveOverrides struct {
+	HomeFunc HomeUserFunc
+	AbsFunc  AbsFunc
+}
+
+// ResolvePath performs 2 forms of path resolution. The first is resolving a
+// home path reference, via the ~ character; ~ is replaced by the user's
+// home path. The second resolves ./ or ../ relative path. The overrides
+// does not need to be provided
+func ResolvePath(path string, overrides ...ResolveOverrides) string {
+	result := path
+
+	if len(overrides) > 0 {
+		override := overrides[0]
+		if result[0] == '~' {
+			result = filepath.Join(override.HomeFunc(), result[1:])
+		} else {
+			a, err := override.AbsFunc(result)
+
+			if err == nil {
+				result = a
+			}
+		}
+	} else {
+		if result[0] == '~' {
+			if h, err := os.UserHomeDir(); err == nil {
+				result = filepath.Join(h, result[1:])
+			}
+		} else {
+			if a, err := filepath.Abs(result); err == nil {
+				result = a
+			}
+		}
+	}
+
+	return result
+}

xfs/utils/resolve-path_test.go

@@ -0,0 +1,103 @@
+package utils_test
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"github.com/snivilised/extendio/xfs/utils"
+)
+
+type RPEntry struct {
+	given  string
+	should string
+	path   string
+	expect string
+}
+
+var fakeHome = filepath.Join(string(filepath.Separator), "home", "rabbitweed")
+var fakeAbs = filepath.Join(string(filepath.Separator), "home", "rabbitweed", "music", "xpander")
+var fakeUpAbs = filepath.Join(string(filepath.Separator), "home", "rabbitweed", "music")
+
+func fakeHomeResolver() string {
+	return fakeHome
+}
+
+func fakeAbsResolver(path string) (string, error) {
+	if strings.HasPrefix(path, "..") {
+		return filepath.Join(fakeUpAbs, path[2:]), nil
+	}
+
+	if strings.HasPrefix(path, ".") {
+		return filepath.Join(fakeAbs, path[1:]), nil
+	}
+
+	return path, nil
+}
+
+var _ = Describe("ResolvePath", func() {
+	DescribeTable("Overrides provided",
+		func(entry *RPEntry) {
+			overrides := utils.ResolveOverrides{
+				HomeFunc: fakeHomeResolver,
+				AbsFunc:  fakeAbsResolver,
+			}
+
+			if filepath.Separator == '/' {
+				actual := utils.ResolvePath(entry.path, overrides)
+				Expect(actual).To(Equal(entry.expect))
+			} else {
+				normalisedPath := strings.ReplaceAll(entry.path, "/", string(filepath.Separator))
+				normalisedExpect := strings.ReplaceAll(entry.expect, "/", string(filepath.Separator))
+
+				actual := utils.ResolvePath(normalisedPath, overrides)
+				Expect(actual).To(Equal(normalisedExpect))
+			}
+		},
+		func(entry *RPEntry) string {
+			return fmt.Sprintf("🧪 ===> given: '%v', should: '%v'", entry.given, entry.should)
+		},
+
+		Entry(nil, &RPEntry{
+			given:  "path is a valid absolute path",
+			should: "return path unmodified",
+			path:   "/home/rabbitweed/foo",
+			expect: "/home/rabbitweed/foo",
+		}),
+		Entry(nil, &RPEntry{
+			given:  "path contains leading ~",
+			should: "replace ~ with home path",
+			path:   "~/foo",
+			expect: "/home/rabbitweed/foo",
+		}),
+		Entry(nil, &RPEntry{
+			given:  "path is relative to cwd",
+			should: "replace ~ with home path",
+			path:   "./foo",
+			expect: "/home/rabbitweed/music/xpander/foo",
+		}),
+		Entry(nil, &RPEntry{
+			given:  "path is relative to parent",
+			should: "replace ~ with home path",
+			path:   "../foo",
+			expect: "/home/rabbitweed/music/foo",
+		}),
+	)
+
+	When("No overrides provided", func() {
+		Context("and: home", func() {
+			It("🧪 should: not fail", func() {
+				utils.ResolvePath("~/")
+			})
+		})
+
+		Context("and: abs", func() {
+			It("🧪 should: not fail", func() {
+				utils.ResolvePath("./")
+			})
+		})
+	})
+})