feat: following #4

* Create an empty config yaml file when config file not exists.

* Enables the http module to use the configured proxy as well.

internal/config/config.go

@@ -17,19 +17,33 @@
 package config
 
 import (
+	"github.com/version-fox/vfox/internal/util"
 	"gopkg.in/yaml.v3"
 	"os"
 	"path/filepath"
 )
 
 type Config struct {
-	Proxy Proxy `yaml:"proxy"`
+	Proxy *Proxy `yaml:"proxy"`
 }
 
 const filename = "config.yaml"
 
+var (
+	defaultConfig = &Config{
+		Proxy: EmptyProxy,
+	}
+)
+
 func NewConfig(path string) (*Config, error) {
 	p := filepath.Join(path, filename)
+	if !util.FileExists(p) {
+		content, err := yaml.Marshal(defaultConfig)
+		if err != nil {
+			_ = os.WriteFile(p, content, 0644)
+			return defaultConfig, nil
+		}
+	}
 	content, err := os.ReadFile(p)
 	if err != nil {
 		return nil, err

internal/config/proxy.go

@@ -20,3 +20,10 @@ type Proxy struct {
 	Url    string `yaml:"url"`
 	Enable bool   `yaml:"enable"`
 }
+
+var (
+	EmptyProxy = &Proxy{
+		Url:    "",
+		Enable: false,
+	}
+)

internal/manager.go

@@ -48,7 +48,7 @@ type Manager struct {
 	Record     env.Record
 	osType     util.OSType
 	archType   util.ArchType
-	config     *config.Config
+	Config     *config.Config
 }
 
 func (m *Manager) EnvKeys() env.Envs {
@@ -92,7 +92,7 @@ func (m *Manager) LookupSdk(name string) (*Sdk, error) {
 	if err != nil {
 		return nil, err
 	}
-	luaPlugin, err := NewLuaPlugin(content, pluginPath, m.osType, m.archType)
+	luaPlugin, err := NewLuaPlugin(content, pluginPath, m)
 	if err != nil {
 		return nil, err
 	}
@@ -115,7 +115,7 @@ func (m *Manager) LoadAllSdk() (map[string]*Sdk, error) {
 			// filename first as sdk name
 			path := filepath.Join(m.PathMeta.PluginPath, d.Name())
 			content, _ := m.loadLuaFromFileOrUrl(path)
-			source, err := NewLuaPlugin(content, path, m.osType, m.archType)
+			source, err := NewLuaPlugin(content, path, m)
 			if err != nil {
 				pterm.Printf("Failed to load %s plugin, err: %s\n", path, err)
 				continue
@@ -168,7 +168,7 @@ func (m *Manager) Update(pluginName string) error {
 	if err != nil {
 		return fmt.Errorf("fetch plugin failed, err: %w", err)
 	}
-	source, err := NewLuaPlugin(content, updateUrl, m.osType, m.archType)
+	source, err := NewLuaPlugin(content, updateUrl, m)
 	if err != nil {
 		return fmt.Errorf("check %s plugin failed, err: %w", updateUrl, err)
 	}
@@ -229,7 +229,7 @@ func (m *Manager) Add(pluginName, url, alias string) error {
 		return fmt.Errorf("failed to load plugin: %w", err)
 	}
 	pterm.Println("Checking plugin...")
-	source, err := NewLuaPlugin(content, url, m.osType, m.archType)
+	source, err := NewLuaPlugin(content, url, m)
 	if err != nil {
 		return fmt.Errorf("check plugin error: %w", err)
 	}
@@ -258,23 +258,30 @@ func (m *Manager) Add(pluginName, url, alias string) error {
 	return nil
 }
 
+func (m *Manager) httpClient() *http.Client {
+	var client *http.Client
+	if m.Config.Proxy.Enable {
+		if uri, err := url.Parse(m.Config.Proxy.Url); err == nil {
+			transPort := &http.Transport{
+				Proxy: http.ProxyURL(uri),
+			}
+			client = &http.Client{
+				Transport: transPort,
+			}
+		}
+	} else {
+		client = http.DefaultClient
+	}
+
+	return client
+}
+
 func (m *Manager) loadLuaFromFileOrUrl(path string) (string, error) {
 	if !strings.HasSuffix(path, ".lua") {
 		return "", fmt.Errorf("%s not a lua file", path)
 	}
 	if strings.HasPrefix(path, "https://") || strings.HasPrefix(path, "http://") {
-		client := http.Client{}
-		if m.config.Proxy.Enable {
-			uri, err := url.Parse(m.config.Proxy.Url)
-			if err == nil {
-				transPort := &http.Transport{
-					Proxy: http.ProxyURL(uri),
-				}
-				client = http.Client{
-					Transport: transPort,
-				}
-			}
-		}
+		client := m.httpClient()
 		resp, err := client.Get(path)
 		if err != nil {
 			return "", err
@@ -312,19 +319,7 @@ func (m *Manager) loadLuaFromFileOrUrl(path string) (string, error) {
 }
 
 func (m *Manager) Available() ([]*Category, error) {
-	// FIX proxy
-	client := http.Client{}
-	if m.config.Proxy.Enable {
-		uri, err := url.Parse(m.config.Proxy.Url)
-		if err == nil {
-			transPort := &http.Transport{
-				Proxy: http.ProxyURL(uri),
-			}
-			client = http.Client{
-				Transport: transPort,
-			}
-		}
-	}
+	client := m.httpClient()
 	resp, err := client.Get(pluginIndexUrl)
 	if err != nil {
 		return nil, fmt.Errorf("get plugin index error: %w", err)
@@ -410,7 +405,7 @@ func newSdkManager(record env.Record, meta *PathMeta) *Manager {
 	}
 	c, err := config.NewConfig(meta.ConfigPath)
 	if err != nil {
-		panic(fmt.Errorf("init config error: %w", err))
+		panic(fmt.Errorf("init Config error: %w", err))
 	}
 	manager := &Manager{
 		PathMeta:   meta,
@@ -419,7 +414,7 @@ func newSdkManager(record env.Record, meta *PathMeta) *Manager {
 		openSdks:   make(map[string]*Sdk),
 		osType:     util.GetOSType(),
 		archType:   util.GetArchType(),
-		config:     c,
+		Config:     c,
 	}
 	return manager
 }

internal/module/http/http.go

@@ -17,33 +17,18 @@
 package http
 
 import (
+	"github.com/version-fox/vfox/internal/config"
 	lua "github.com/yuin/gopher-lua"
 	"io"
 	"net/http"
+	"net/url"
 )
 
-// Preload adds json to the given Lua state's package.preload table. After it
-// has been preloaded, it can be loaded using require:
-//
-//	local json = require("http")
-func Preload(L *lua.LState) {
-	L.PreloadModule("http", loader)
-}
-
-// loader is the module loader function.
-func loader(L *lua.LState) int {
-	t := L.NewTable()
-	L.SetFuncs(t, api)
-	L.Push(t)
-	return 1
+type Module struct {
+	proxy *config.Proxy
 }
 
-var api = map[string]lua.LGFunction{
-	"get": getRequest,
-	// TODO wait to extend
-}
-
-// getRequest performs a http get request
+// Get performs a http get request
 // @param url string
 // @param headers table
 // @return resp table
@@ -59,15 +44,27 @@ var api = map[string]lua.LGFunction{
 //	    status_code = 200,
 //	    headers = table
 //	}
-func getRequest(L *lua.LState) int {
+func (m *Module) Get(L *lua.LState) int {
 	param := L.CheckTable(1)
-	url := param.RawGetString("url")
-	if url == lua.LNil {
+	urlStr := param.RawGetString("url")
+	if urlStr == lua.LNil {
 		L.Push(lua.LNil)
 		L.Push(lua.LString("url is required"))
 	}
+
 	client := &http.Client{}
-	req, err := http.NewRequest("GET", url.String(), nil)
+	if m.proxy.Enable {
+		uri, err := url.Parse(m.proxy.Url)
+		if err == nil {
+			transPort := &http.Transport{
+				Proxy: http.ProxyURL(uri),
+			}
+			client = &http.Client{
+				Transport: transPort,
+			}
+		}
+	}
+	req, err := http.NewRequest("GET", urlStr.String(), nil)
 	if err != nil {
 		L.Push(lua.LNil)
 		L.Push(lua.LString(err.Error()))
@@ -108,3 +105,19 @@ func getRequest(L *lua.LState) int {
 	L.Push(result)
 	return 1
 }
+
+func (m *Module) luaMap() map[string]lua.LGFunction {
+	return map[string]lua.LGFunction{
+		"get": m.Get,
+	}
+}
+
+func NewModule(proxy *config.Proxy) lua.LGFunction {
+	return func(L *lua.LState) int {
+		m := &Module{proxy: proxy}
+		t := L.NewTable()
+		L.SetFuncs(t, m.luaMap())
+		L.Push(t)
+		return 1
+	}
+}

internal/module/http/http_test.go

@@ -17,10 +17,32 @@
 package http
 
 import (
+	"github.com/version-fox/vfox/internal/config"
 	lua "github.com/yuin/gopher-lua"
 	"testing"
 )
 
+func TestWithConfig(t *testing.T) {
+	const str = `	
+	local http = require("http")
+	assert(type(http) == "table")
+	assert(type(http.get) == "function")
+	local resp, err = http.get({
+        url = "http://ip.jsontest.com/"
+    })
+	assert(err == 'Get "http://ip.jsontest.com/": proxyconnect tcp: dial tcp 127.0.0.1:80: connect: connection refused')
+	`
+	s := lua.NewState()
+	defer s.Close()
+
+	s.PreloadModule("http", NewModule(&config.Proxy{
+		Enable: true,
+		Url:    "http://localhost",
+	}))
+	if err := s.DoString(str); err != nil {
+		t.Error(err)
+	}
+}
 func TestGetRequest(t *testing.T) {
 	const str = `	
 	local http = require("http")
@@ -33,10 +55,14 @@ func TestGetRequest(t *testing.T) {
 	assert(resp.status_code == 200)
 	assert(resp.headers['Content-Type'] == 'application/json')
 	`
+	eval(str, t)
+}
+
+func eval(str string, t *testing.T) {
 	s := lua.NewState()
 	defer s.Close()
 
-	Preload(s)
+	s.PreloadModule("http", NewModule(config.EmptyProxy))
 	if err := s.DoString(str); err != nil {
 		t.Error(err)
 	}

internal/module/module.go

@@ -17,14 +17,15 @@
 package module
 
 import (
+	"github.com/version-fox/vfox/internal/config"
 	"github.com/version-fox/vfox/internal/module/html"
 	"github.com/version-fox/vfox/internal/module/http"
 	"github.com/version-fox/vfox/internal/module/json"
 	lua "github.com/yuin/gopher-lua"
 )
 
-func Preload(L *lua.LState) {
-	http.Preload(L)
+func Preload(L *lua.LState, config *config.Config) {
+	L.PreloadModule("http", http.NewModule(config.Proxy))
 	json.Preload(L)
 	html.Preload(L)
 }

internal/plugin.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"github.com/version-fox/vfox/internal/env"
 	"github.com/version-fox/vfox/internal/module"
-	"github.com/version-fox/vfox/internal/util"
 	lua "github.com/yuin/gopher-lua"
 	"regexp"
 )
@@ -318,16 +317,16 @@ func (l *LuaPlugin) Label(version string) string {
 	return fmt.Sprintf("%s@%s", l.Name, version)
 }
 
-func NewLuaPlugin(content, path string, osType util.OSType, archType util.ArchType) (*LuaPlugin, error) {
+func NewLuaPlugin(content, path string, manager *Manager) (*LuaPlugin, error) {
 	luaVMInstance := lua.NewState()
-	module.Preload(luaVMInstance)
+	module.Preload(luaVMInstance, manager.Config)
 	if err := luaVMInstance.DoString(content); err != nil {
 		return nil, err
 	}
 
 	// set OS_TYPE and ARCH_TYPE
-	luaVMInstance.SetGlobal(OsType, lua.LString(osType))
-	luaVMInstance.SetGlobal(ArchType, lua.LString(archType))
+	luaVMInstance.SetGlobal(OsType, lua.LString(manager.osType))
+	luaVMInstance.SetGlobal(ArchType, lua.LString(manager.archType))
 
 	pluginObj := luaVMInstance.GetGlobal(LuaPluginObjKey)
 	if pluginObj.Type() == lua.LTNil {