X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=cmd%2Fmicro%2Fplugin.go;h=d77baea9ba5fdf4e3c6eaecc757bfe553323aa4b;hb=3ecdd96931ac75039105b5a4ac2fdd3b5526dbf6;hp=6401970b20ab6193012ebe7036e190e2ffdf1d36;hpb=68189fd4066ea7b41455535c2b0810b09bc3b479;p=micro.git

diff --git a/cmd/micro/plugin.go b/cmd/micro/plugin.go
index 6401970b..d77baea9 100644
--- a/cmd/micro/plugin.go
+++ b/cmd/micro/plugin.go
@@ -3,40 +3,56 @@ package main
 import (
 	"errors"
 	"io/ioutil"
+	"os"
+	"strings"
 
+	"github.com/layeh/gopher-luar"
 	"github.com/yuin/gopher-lua"
 )
 
 var loadedPlugins []string
 
-var preInstalledPlugins = []string{
-	"go",
-	"linter",
-}
-
 // Call calls the lua function 'function'
 // If it does not exist nothing happens, if there is an error,
 // the error is returned
-func Call(function string) error {
-	luaFunc := L.GetGlobal(function)
+func Call(function string, args ...interface{}) (lua.LValue, error) {
+	var luaFunc lua.LValue
+	if strings.Contains(function, ".") {
+		plugin := L.GetGlobal(strings.Split(function, ".")[0])
+		if plugin.String() == "nil" {
+			return nil, errors.New("function does not exist: " + function)
+		}
+		luaFunc = L.GetField(plugin, strings.Split(function, ".")[1])
+	} else {
+		luaFunc = L.GetGlobal(function)
+	}
+
 	if luaFunc.String() == "nil" {
-		return errors.New("function does not exist: " + function)
+		return nil, errors.New("function does not exist: " + function)
+	}
+	var luaArgs []lua.LValue
+	for _, v := range args {
+		luaArgs = append(luaArgs, luar.New(L, v))
 	}
 	err := L.CallByParam(lua.P{
 		Fn:      luaFunc,
-		NRet:    0,
+		NRet:    1,
 		Protect: true,
-	})
-	return err
+	}, luaArgs...)
+	ret := L.Get(-1) // returned value
+	if ret.String() != "nil" {
+		L.Pop(1) // remove received value
+	}
+	return ret, err
 }
 
 // LuaFunctionBinding is a function generator which takes the name of a lua function
 // and creates a function that will call that lua function
 // Specifically it creates a function that can be called as a binding because this is used
 // to bind keys to lua functions
-func LuaFunctionBinding(function string) func(*View) bool {
-	return func(v *View) bool {
-		err := Call(function)
+func LuaFunctionBinding(function string) func(*View, bool) bool {
+	return func(v *View, _ bool) bool {
+		_, err := Call(function, nil)
 		if err != nil {
 			TermMessage(err)
 		}
@@ -44,47 +60,92 @@ func LuaFunctionBinding(function string) func(*View) bool {
 	}
 }
 
+func unpack(old []string) []interface{} {
+	new := make([]interface{}, len(old))
+	for i, v := range old {
+		new[i] = v
+	}
+	return new
+}
+
 // LuaFunctionCommand is the same as LuaFunctionBinding except it returns a normal function
 // so that a command can be bound to a lua function
-func LuaFunctionCommand(function string) func() {
-	return func() {
-		err := Call(function)
+func LuaFunctionCommand(function string) func([]string) {
+	return func(args []string) {
+		_, err := Call(function, unpack(args)...)
 		if err != nil {
 			TermMessage(err)
 		}
 	}
 }
 
-// LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
-func LoadPlugins() {
-	files, _ := ioutil.ReadDir(configDir + "/plugins")
-	for _, plugin := range files {
-		if plugin.IsDir() {
-			pluginName := plugin.Name()
-			files, _ := ioutil.ReadDir(configDir + "/plugins/" + pluginName)
-			for _, f := range files {
-				if f.Name() == pluginName+".lua" {
-					if err := L.DoFile(configDir + "/plugins/" + pluginName + "/" + f.Name()); err != nil {
-						TermMessage(err)
-						continue
-					}
-					loadedPlugins = append(loadedPlugins, pluginName)
+// LuaFunctionComplete returns a function which can be used for autocomplete in plugins
+func LuaFunctionComplete(function string) func(string) []string {
+	return func(input string) (result []string) {
+
+		res, err := Call(function, input)
+		if err != nil {
+			TermMessage(err)
+		}
+		if tbl, ok := res.(*lua.LTable); !ok {
+			TermMessage(function, "should return a table of strings")
+		} else {
+			for i := 1; i <= tbl.Len(); i++ {
+				val := tbl.RawGetInt(i)
+				if v, ok := val.(lua.LString); !ok {
+					TermMessage(function, "should return a table of strings")
+				} else {
+					result = append(result, string(v))
 				}
 			}
 		}
+		return result
 	}
+}
 
-	for _, pluginName := range preInstalledPlugins {
-		plugin := "runtime/plugins/" + pluginName + "/" + pluginName + ".lua"
-		data, err := Asset(plugin)
+func LuaFunctionJob(function string) func(string, ...string) {
+	return func(output string, args ...string) {
+		_, err := Call(function, unpack(append([]string{output}, args...))...)
 		if err != nil {
-			TermMessage("Error loading pre-installed plugin: " + pluginName)
-			continue
+			TermMessage(err)
+		}
+	}
+}
+
+// LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
+func LoadPlugins() {
+	for _, plugin := range ListRuntimeFiles(RTPlugin) {
+		alreadyExists := false
+		pluginName := plugin.Name()
+		for _, pl := range loadedPlugins {
+			if pl == pluginName {
+				alreadyExists = true
+				break
+			}
+		}
+
+		if !alreadyExists {
+			data, err := plugin.Data()
+			if err != nil {
+				TermMessage("Error loading plugin: " + pluginName)
+				continue
+			}
+			pluginDef := "\nlocal P = {}\n" + pluginName + " = P\nsetmetatable(" + pluginName + ", {__index = _G})\nsetfenv(1, P)\n"
+
+			if err := L.DoString(pluginDef + string(data)); err != nil {
+				TermMessage(err)
+				continue
+			}
+			loadedPlugins = append(loadedPlugins, pluginName)
 		}
-		if err := L.DoString(string(data)); err != nil {
+	}
+
+	if _, err := os.Stat(configDir + "/init.lua"); err == nil {
+		pluginDef := "\nlocal P = {}\n" + "init" + " = P\nsetmetatable(" + "init" + ", {__index = _G})\nsetfenv(1, P)\n"
+		data, _ := ioutil.ReadFile(configDir + "/init.lua")
+		if err := L.DoString(pluginDef + string(data)); err != nil {
 			TermMessage(err)
-			continue
 		}
-		loadedPlugins = append(loadedPlugins, pluginName)
+		loadedPlugins = append(loadedPlugins, "init")
 	}
 }