Hilbish/rl.go

package main

import (
	"fmt"
	"io"
	"path/filepath"
	"strings"
	"os"

	"github.com/maxlandon/readline"
	"github.com/yuin/gopher-lua"
)

type lineReader struct {
	rl *readline.Instance
}
var fileHist *fileHistory

// other gophers might hate this naming but this is local, shut up
func newLineReader(prompt string) *lineReader {
	rl := readline.NewInstance()
	fh, err := newFileHistory()
	fileHist = fh // go stupid
	if err != nil {
		panic(err)
	}
	rl.SetHistoryCtrlR("file", fileHist)
	rl.ShowVimMode = false
	rl.ViModeCallback = func(mode readline.ViMode) {
		modeStr := ""
		switch mode {
			case readline.VimKeys: modeStr = "normal"
			case readline.VimInsert: modeStr = "insert"
			case readline.VimDelete: modeStr = "delete"
			case readline.VimReplaceOnce:
			case readline.VimReplaceMany: modeStr = "replace"
		}
		setVimMode(modeStr)
	}
	rl.TabCompleter = func(line []rune, pos int, _ readline.DelayedTabContext) (string, []*readline.CompletionGroup) {
		ctx := string(line)
		var completions []string
		
		compGroup := []*readline.CompletionGroup{
			&readline.CompletionGroup{
				TrimSlash: false,
				NoSpace: true,
			},
		}

		ctx = strings.TrimLeft(ctx, " ")
		if len(ctx) == 0 {
			return "", compGroup
		}

		fields := strings.Split(ctx, " ")
		if len(fields) == 0 {
			return "", compGroup
		}
		query := fields[len(fields) - 1]

		ctx = aliases.Resolve(ctx)
		
		if len(fields) == 1 {
			prefixes := []string{"./", "../", "/", "~/"}
			for _, prefix := range prefixes {
				if strings.HasPrefix(query, prefix) {
					fileCompletions := fileComplete(query, ctx, fields)
					if len(fileCompletions) != 0 {
						for _, f := range fileCompletions {
							name := strings.Replace(query + f, "~", curuser.HomeDir, 1)
							if info, err := os.Stat(name); err == nil && info.Mode().Perm() & 0100 == 0 {
								continue
							}
							completions = append(completions, f)
						}
						compGroup[0].Suggestions = completions
					}
					return "", compGroup
				}
			}

			// filter out executables, but in path
			for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
				// print dir to stderr for debugging
				// search for an executable which matches our query string
				if matches, err := filepath.Glob(filepath.Join(dir, query + "*")); err == nil {
					// get basename from matches
					for _, match := range matches {
						// check if we have execute permissions for our match
						if info, err := os.Stat(match); err == nil && info.Mode().Perm() & 0100 == 0 {
							continue
						}
						// get basename from match
						name := filepath.Base(match)
						// print name to stderr for debugging
						// add basename to completions
						completions = append(completions, name)
					}
				}
			}
			
			// add lua registered commands to completions
			for cmdName := range commands {
				if strings.HasPrefix(cmdName, query) {
					completions = append(completions, cmdName)
				}
			}
			
			compGroup[0].Suggestions = completions
			return query, compGroup
		} else {
			if completecb, ok := luaCompletions["command." + fields[0]]; ok {
				err := l.CallByParam(lua.P{
					Fn: completecb,
					NRet: 1,
					Protect: true,
				})

				if err != nil {
					return "", compGroup
				}

				luacompleteTable := l.Get(-1)
				l.Pop(1)

				if cmpTbl, ok := luacompleteTable.(*lua.LTable); ok {
					cmpTbl.ForEach(func(key lua.LValue, value lua.LValue) {
						// if key is a number (index), we just check and complete that
						if key.Type() == lua.LTNumber {
							// if we have only 2 fields then this is fine
							if len(fields) == 2 {
								if strings.HasPrefix(value.String(), fields[1]) {
									completions = append(completions, value.String())
								}
							}
						} else if key.Type() == lua.LTString {
							if len(fields) == 2 {
								if strings.HasPrefix(key.String(), fields[1]) {
									completions = append(completions, key.String())
								}
							} else {
								// if we have more than 2 fields, we need to check if the key matches
								// the current field and if it does, we need to check if the value is a string
								// or table (nested sub completions)
								if key.String() == fields[1] {
									// if value is a table, we need to iterate over it
									// and add each value to completions
									// check if value is either a table or function
									if value.Type() == lua.LTTable {
										valueTbl := value.(*lua.LTable)
										valueTbl.ForEach(func(key lua.LValue, value lua.LValue) {
											val := value.String()
											if val == "<file>" {
												// complete files
												completions = append(completions, fileComplete(query, ctx, fields)...)
											} else {
												if strings.HasPrefix(val, query) {
													completions = append(completions, val)
												}
											}
										})
									} else if value.Type() == lua.LTFunction {
										// if value is a function, we need to call it
										// and add each value to completions
										// completionsCtx is the context we pass to the function,
										// removing 2 fields from the fields array
										completionsCtx := strings.Join(fields[2:], " ")
										err := l.CallByParam(lua.P{
											Fn: value,
											NRet: 1,
											Protect: true,
										}, lua.LString(query), lua.LString(completionsCtx))

										if err != nil {
											return
										}

										luacompleteTable := l.Get(-1)
										l.Pop(1)

										// just check if its actually a table and add it to the completions
										if cmpTbl, ok := luacompleteTable.(*lua.LTable); ok {
											cmpTbl.ForEach(func(key lua.LValue, value lua.LValue) {
												val := value.String()
												if strings.HasPrefix(val, query) {
													completions = append(completions, val)
												}
											})
										}
									} else {
										// throw lua error
										// complete.cmdname: error message...
										l.RaiseError("complete." + fields[0] + ": completion value is not a table or function")
									}
								}
							}
						}
					})
				}
			}

			if len(completions) == 0 {
				completions = fileComplete(query, ctx, fields)
			}
		}

		compGroup[0].Suggestions = completions
		return "", compGroup
	}

	return &lineReader{
		rl,
	}
}

func (lr *lineReader) Read() (string, error) {
	hooks.Em.Emit("command.precmd", nil)
	s, err := lr.rl.Readline()
	// this is so dumb
	if err == readline.EOF {
		fmt.Println("")
		return "", io.EOF
	}

	return s, err // might get another error
}

func (lr *lineReader) SetPrompt(prompt string) {
	halfPrompt := strings.Split(prompt, "\n")
	if len(halfPrompt) > 1 {
		lr.rl.Multiline = true
		lr.rl.SetPrompt(strings.Join(halfPrompt[:len(halfPrompt) - 1], "\n"))
		lr.rl.MultilinePrompt = halfPrompt[len(halfPrompt) - 1:][0]
	} else {
		lr.rl.Multiline = false
		lr.rl.SetPrompt(prompt)
	}
	if !running {
		lr.rl.RefreshPromptInPlace("")
	}
}

func (lr *lineReader) AddHistory(cmd string) {
	fileHist.Write(cmd)
}

func (lr *lineReader) ClearInput() {
	return
}

func (lr *lineReader) Resize() {
	return
}

// lua module
func (lr *lineReader) Loader(L *lua.LState) *lua.LTable {
	lrLua := map[string]lua.LGFunction{
		"add": lr.luaAddHistory,
		"all": lr.luaAllHistory,
		"clear": lr.luaClearHistory,
		"get": lr.luaGetHistory,
		"size": lr.luaSize,
	}

	mod := l.SetFuncs(l.NewTable(), lrLua)

	return mod
}

func (lr *lineReader) luaAddHistory(l *lua.LState) int {
	cmd := l.CheckString(1)
	lr.AddHistory(cmd)

	return 0
}

func (lr *lineReader) luaSize(L *lua.LState) int {
	L.Push(lua.LNumber(fileHist.Len()))

	return 1
}

func (lr *lineReader) luaGetHistory(L *lua.LState) int {
	idx := L.CheckInt(1)
	cmd, _ := fileHist.GetLine(idx)
	L.Push(lua.LString(cmd))

	return 0
}

func (lr *lineReader) luaAllHistory(L *lua.LState) int {
	tbl := L.NewTable()
	size := fileHist.Len()

	for i := 1; i < size; i++ {
		cmd, _ := fileHist.GetLine(i)
		tbl.Append(lua.LString(cmd))
	}

	L.Push(tbl)

	return 0
}

func (lr *lineReader) luaClearHistory(l *lua.LState) int {
	return 0

}