feat: unmarshal hook result

version-fox · Mar 6, 2024 · f99b172 · f99b172
1 parent 0edeb1d
commit f99b172
Show file tree

Hide file tree

Showing 3 changed files with 130 additions and 74 deletions.
diff --git a/internal/luai/interfaces.go b/internal/luai/interfaces.go
@@ -18,11 +18,32 @@ type AvailableHookCtx struct {
 	RuntimeVersion string `luai:"runtimeVersion"`
 }
 
+type AvailableHookResultItem struct {
+	Version string `luai:"version"`
+	Note    string `luai:"note"`
+
+	Addition []*LuaSDKInfo `luai:"addition"`
+}
+
 type PreInstallHookCtx struct {
 	Version        string `luai:"version"`
 	RuntimeVersion string `luai:"runtimeVersion"`
 }
 
+type PreInstallHookResultAdditionItem struct {
+	Name string `luai:"name"`
+	Url  string `luai:"url"`
+	LuaCheckSum
+}
+
+type PreInstallHookResult struct {
+	Version string `luai:"version"`
+	Url     string `luai:"url"`
+	LuaCheckSum
+
+	Addition []*LuaSDKInfo `luai:"addition"`
+}
+
 type PreUseHookCtx struct {
 	RuntimeVersion  string                 `luai:"runtimeVersion"`
 	Cwd             string                 `luai:"cwd"`
@@ -32,6 +53,10 @@ type PreUseHookCtx struct {
 	InstalledSdks   map[string]*LuaSDKInfo `luai:"installedSdks"`
 }
 
+type PreUseHookResult struct {
+	Version string `luai:"version"`
+}
+
 type PostInstallHookCtx struct {
 	RuntimeVersion string                 `luai:"runtimeVersion"`
 	RootPath       string                 `luai:"rootPath"`
@@ -44,3 +69,8 @@ type EnvKeysHookCtx struct {
 	Path    string                 `luai:"path"`
 	SdkInfo map[string]*LuaSDKInfo `luai:"sdkInfo"`
 }
+
+type EnvKeysHookResultItem struct {
+	Key   string `luai:"key"`
+	Value string `luai:"value"`
+}
diff --git a/internal/plugin.go b/internal/plugin.go
@@ -18,6 +18,7 @@ package internal
 
 import (
 	_ "embed"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"regexp"
@@ -103,47 +104,43 @@ func (l *LuaPlugin) Available() ([]*Package, error) {
 	if table == nil || table.Type() == lua.LTNil {
 		return []*Package{}, nil
 	}
+
+	hookResult := []luai.AvailableHookResultItem{}
+	err = luai.Unmarshal(table, &hookResult)
+	if err != nil {
+		return nil, errors.New("failed to unmarshal the return value: " + err.Error())
+	}
+
 	var result []*Package
-	table.ForEach(func(key lua.LValue, value lua.LValue) {
-		kvTable, ok := value.(*lua.LTable)
-		if !ok {
-			err = fmt.Errorf("the return value is not a table")
-			return
-		}
-		mainSdk, err := l.parseInfo(kvTable)
-		if err != nil {
-			return
+
+	for _, item := range hookResult {
+		fmt.Printf("item: %+v\n", item)
+
+		mainSdk := &Info{
+			Name:    l.Name,
+			Version: Version(item.Version),
+			Note:    item.Note,
 		}
-		mainSdk.Name = l.Name
+
 		var additionalArr []*Info
-		additional := kvTable.RawGetString("addition")
-		if tb, ok := additional.(*lua.LTable); ok && tb.Len() != 0 {
-			additional.(*lua.LTable).ForEach(func(key lua.LValue, value lua.LValue) {
-				itemTable, ok := value.(*lua.LTable)
-				if !ok {
-					err = fmt.Errorf("the return value is not a table")
-					return
-				}
-				item, err := l.parseInfo(itemTable)
-				if err != nil {
-					return
-				}
-				if item.Name == "" {
-					err = fmt.Errorf("additional file no name provided")
-					return
-				}
-				additionalArr = append(additionalArr, item)
+
+		for i, addition := range item.Addition {
+			if addition.Name == "" {
+				logger.Errorf("additional file %d no name provided", i+1)
+			}
+
+			additionalArr = append(additionalArr, &Info{
+				Name:    addition.Name,
+				Version: Version(addition.Version),
+				Path:    addition.Path,
+				Note:    addition.Note,
 			})
 		}
 
 		result = append(result, &Package{
 			Main:      mainSdk,
 			Additions: additionalArr,
 		})
-
-	})
-	if err != nil {
-		return nil, err
 	}
 
 	return result, nil
@@ -237,40 +234,34 @@ func (l *LuaPlugin) PreInstall(version Version) (*Package, error) {
 }
 
 func (l *LuaPlugin) parseInfo(table *lua.LTable) (*Info, error) {
-	versionLua := table.RawGetString("version")
-	if versionLua == lua.LNil {
-		return nil, fmt.Errorf("no version number provided")
+	info := &luai.LuaSDKInfo{}
+	err := luai.Unmarshal(table, info)
+	if err != nil {
+		return nil, err
 	}
-	var (
-		path    string
-		note    string
-		name    string
-		version string
-	)
-	version = versionLua.String()
 
-	if urlLua := table.RawGetString("url"); urlLua != lua.LNil {
-		path = urlLua.String()
-	}
-	if noteLua := table.RawGetString("note"); noteLua != lua.LNil {
-		note = noteLua.String()
-	}
-	if nameLua := table.RawGetString("name"); nameLua != lua.LNil {
-		name = nameLua.String()
+	if info.Version == "" {
+		return nil, fmt.Errorf("no version number provided")
 	}
+
 	checksum := l.Checksum(table)
 	return &Info{
-		Name:     name,
-		Version:  Version(version),
-		Path:     path,
-		Note:     note,
+		Name:     info.Name,
+		Version:  Version(info.Version),
+		Path:     info.Path,
+		Note:     info.Name,
 		Checksum: checksum,
 	}, nil
 }
 
 func (l *LuaPlugin) PostInstall(rootPath string, sdks []*Info) error {
 	L := l.vm.Instance
 
+	function := l.pluginObj.RawGetString(PostInstallHook)
+	if function.Type() == lua.LTNil {
+		return nil
+	}
+
 	ctx := &luai.PostInstallHookCtx{
 		RuntimeVersion: RuntimeVersion,
 		RootPath:       rootPath,
@@ -286,11 +277,6 @@ func (l *LuaPlugin) PostInstall(rootPath string, sdks []*Info) error {
 		return err
 	}
 
-	function := l.pluginObj.RawGetString(PostInstallHook)
-	if function.Type() == lua.LTNil {
-		return nil
-	}
-
 	if err := l.vm.CallFunction(function, l.pluginObj, ctxTable); err != nil {
 		return err
 	}
@@ -327,22 +313,19 @@ func (l *LuaPlugin) EnvKeys(sdkPackage *Package) (env.Envs, error) {
 	if table == nil || table.Type() == lua.LTNil || table.Len() == 0 {
 		return nil, fmt.Errorf("no environment variables provided")
 	}
+
 	envKeys := make(env.Envs)
-	table.ForEach(func(key lua.LValue, value lua.LValue) {
-		kvTable, ok := value.(*lua.LTable)
-		if !ok {
-			err = fmt.Errorf("the return value is not a table")
-			return
-		}
-		key = kvTable.RawGetString("key")
-		value = kvTable.RawGetString("value")
-		s := value.String()
-		envKeys[key.String()] = &s
-	})
+
+	items := []*luai.EnvKeysHookResultItem{}
+	err = luai.Unmarshal(table, &items)
 	if err != nil {
 		return nil, err
 	}
 
+	for _, item := range items {
+		envKeys[item.Key] = &item.Value
+	}
+
 	return envKeys, nil
 }
 
@@ -392,13 +375,13 @@ func (l *LuaPlugin) PreUse(version Version, previousVersion Version, scope UseSc
 		return "", nil
 	}
 
-	luaVer := l.vm.GetTableString(table, "version")
-	if luaVer == "" {
-		// ignore version field not found
-		return "", nil
+	result := &luai.PreUseHookResult{}
+
+	if err := luai.Unmarshal(table, result); err != nil {
+		return "", err
 	}
 
-	return Version(luaVer), nil
+	return Version(result.Version), nil
 }
 
 func NewLuaPlugin(content, path string, manager *Manager) (*LuaPlugin, error) {

diff --git a/internal/plugin_test.go b/internal/plugin_test.go
@@ -1,6 +1,7 @@
 package internal
 
 import (
+	"strings"
 	"testing"
 
 	_ "embed"
@@ -28,6 +29,48 @@ func TestPlugin(t *testing.T) {
 		}
 	})
 
+	t.Run("EnvKeys", func(t *testing.T) {
+		manager := NewSdkManager()
+
+		plugin, err := NewLuaPlugin(pluginContent, pluginPath, manager)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		keys, err := plugin.EnvKeys(&Package{
+			Main: &Info{
+				Name:    "java",
+				Version: "1.0.0",
+				Path:    "/path/to/java",
+				Note:    "xxxx",
+			},
+			Additions: []*Info{
+				{
+					Name:    "sdk-name",
+					Version: "9.0.0",
+					Path:    "/path/to/sdk",
+					Note:    "xxxx",
+				},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		javaHome := keys["JAVA_HOME"]
+		if *javaHome == "" {
+			t.Errorf("expected JAVA_HOME to be set, got '%s'", *javaHome)
+		}
+		path := keys["PATH"]
+		if *path == "" {
+			t.Errorf("expected PATH to be set, got '%s'", *path)
+		}
+
+		if !strings.HasSuffix(*path, "/bin") {
+			t.Errorf("expected PATH to end with '/bin', got '%s'", *path)
+		}
+	})
+
 	t.Run("PreUse", func(t *testing.T) {
 		manager := NewSdkManager()