internal/info: relocate from internal

This is cleaner and makes more sense. The longer LDFLAGS was never a valid concern since it is always inserted by a script.

Signed-off-by: Ophestra <cat@gensokyo.uk>

3 files changed, 97 insertions, 0 deletions

diff --git a/internal/info/path.go b/internal/info/path.go
new file mode 100644
index 00000000..9f96734a
--- /dev/null
+++ b/internal/info/path.go
@@ -0,0 +1,33 @@
+package info
+
+import (
+	"log"
+
+	"hakurei.app/container/check"
+)
+
+// Absolute paths to the Hakurei installation.
+//
+// These are set by the linker.
+var hakureiPath, hsuPath string
+
+// MustHakureiPath returns the [check.Absolute] path to hakurei.
+func MustHakureiPath() *check.Absolute { return mustCheckPath(log.Fatal, "hakurei", hakureiPath) }
+
+// MustHsuPath returns the [check.Absolute] to hsu.
+func MustHsuPath() *check.Absolute { return mustCheckPath(log.Fatal, "hsu", hsuPath) }
+
+// mustCheckPath checks a pathname to not be zero, then [check.NewAbs], calling fatal if either step fails.
+func mustCheckPath(fatal func(v ...any), name, pathname string) *check.Absolute {
+	if pathname != "" {
+		if a, err := check.NewAbs(pathname); err != nil {
+			fatal(err.Error())
+			return nil // unreachable
+		} else {
+			return a
+		}
+	} else {
+		fatal("invalid " + name + " path, this program is compiled incorrectly")
+		return nil // unreachable
+	}
+}
diff --git a/internal/info/path_test.go b/internal/info/path_test.go
new file mode 100644
index 00000000..3137ee6a
--- /dev/null
+++ b/internal/info/path_test.go
@@ -0,0 +1,45 @@
+package info
+
+import (
+	"reflect"
+	"testing"
+
+	"hakurei.app/container/check"
+)
+
+func TestMustCheckPath(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name      string
+		pathname  string
+		wantFatal string
+	}{
+		{"zero", "", "invalid test path, this program is compiled incorrectly"},
+		{"not absolute", "\x00", `path "\x00" is not absolute`},
+		{"success", "/proc/nonexistent", ""},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			fatal := func(v ...any) { t.Fatal(append([]any{"invalid call to fatal:"}, v...)...) }
+			if tc.wantFatal != "" {
+				fatal = func(v ...any) {
+					if len(v) != 1 {
+						t.Errorf("mustCheckPath: fatal %#v", v)
+					} else if gotFatal, ok := v[0].(string); !ok {
+						t.Errorf("mustCheckPath: fatal = %#v", v[0])
+					} else if gotFatal != tc.wantFatal {
+						t.Errorf("mustCheckPath: fatal = %q, want %q", gotFatal, tc.wantFatal)
+					}
+
+					// do not simulate exit
+				}
+			}
+
+			if got := mustCheckPath(fatal, "test", tc.pathname); got != nil && !reflect.DeepEqual(got, check.MustAbs(tc.pathname)) {
+				t.Errorf("mustCheckPath: %q", got)
+			}
+		})
+	}
+}
diff --git a/internal/info/version.go b/internal/info/version.go
new file mode 100644
index 00000000..8e722f78
--- /dev/null
+++ b/internal/info/version.go
@@ -0,0 +1,19 @@
+package info
+
+// FallbackVersion is returned when a version string was not set by the linker.
+const FallbackVersion = "dirty"
+
+// buildVersion is the Hakurei tree's version string at build time.
+//
+// This is set by the linker.
+var buildVersion string
+
+// Version returns the Hakurei tree's version string.
+// It is either the value of the constant [FallbackVersion] or,
+// when possible, a release tag like "v1.0.0".
+func Version() string {
+	if buildVersion != "" {
+		return buildVersion
+	}
+	return FallbackVersion
+}