mirror of https://github.com/Hilbis/Hilbish
367 lines
8.3 KiB
Go
367 lines
8.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"hilbish/util"
|
|
|
|
"github.com/maxlandon/readline"
|
|
rt "github.com/arnodel/golua/runtime"
|
|
)
|
|
|
|
type lineReader struct {
|
|
rl *readline.Instance
|
|
}
|
|
var fileHist *fileHistory
|
|
var hinter *rt.Closure
|
|
var highlighter *rt.Closure
|
|
|
|
func newLineReader(prompt string, noHist bool) *lineReader {
|
|
rl := readline.NewInstance()
|
|
// we don't mind hilbish.read rl instances having completion,
|
|
// but it cant have shared history
|
|
if !noHist {
|
|
fileHist = newFileHistory()
|
|
rl.SetHistoryCtrlR("History", fileHist)
|
|
rl.HistoryAutoWrite = false
|
|
}
|
|
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.ViActionCallback = func(action readline.ViAction, args []string) {
|
|
actionStr := ""
|
|
switch action {
|
|
case readline.VimActionPaste: actionStr = "paste"
|
|
case readline.VimActionYank: actionStr = "yank"
|
|
}
|
|
hooks.Em.Emit("hilbish.vimAction", actionStr, args)
|
|
}
|
|
rl.HintText = func(line []rune, pos int) []rune {
|
|
if hinter == nil {
|
|
return []rune{}
|
|
}
|
|
|
|
retVal, err := rt.Call1(l.MainThread(), rt.FunctionValue(highlighter),
|
|
rt.StringValue(string(line)), rt.IntValue(int64(pos)))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return []rune{}
|
|
}
|
|
|
|
hintText := ""
|
|
if luaStr, ok := retVal.TryString(); ok {
|
|
hintText = luaStr
|
|
}
|
|
|
|
return []rune(hintText)
|
|
}
|
|
rl.SyntaxHighlighter = func(line []rune) string {
|
|
if highlighter == nil {
|
|
return string(line)
|
|
}
|
|
retVal, err := rt.Call1(l.MainThread(), rt.FunctionValue(highlighter),
|
|
rt.StringValue(string(line)))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return string(line)
|
|
}
|
|
|
|
highlighted := ""
|
|
if luaStr, ok := retVal.TryString(); ok {
|
|
highlighted = luaStr
|
|
}
|
|
|
|
return highlighted
|
|
}
|
|
rl.TabCompleter = func(line []rune, pos int, _ readline.DelayedTabContext) (string, []*readline.CompletionGroup) {
|
|
ctx := string(line)
|
|
|
|
var compGroup []*readline.CompletionGroup
|
|
|
|
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 {
|
|
completions, prefix := binaryComplete(query, ctx, fields)
|
|
|
|
compGroup = append(compGroup, &readline.CompletionGroup{
|
|
TrimSlash: false,
|
|
NoSpace: true,
|
|
Suggestions: completions,
|
|
})
|
|
|
|
return prefix, compGroup
|
|
} else {
|
|
if completecb, ok := luaCompletions["command." + fields[0]]; ok {
|
|
luaFields := rt.NewTable()
|
|
for i, f := range fields {
|
|
luaFields.Set(rt.IntValue(int64(i + 1)), rt.StringValue(f))
|
|
}
|
|
|
|
// we must keep the holy 80 cols
|
|
luacompleteTable, err := rt.Call1(l.MainThread(),
|
|
rt.FunctionValue(completecb), rt.StringValue(query),
|
|
rt.StringValue(ctx), rt.TableValue(luaFields))
|
|
|
|
if err != nil {
|
|
return "", compGroup
|
|
}
|
|
|
|
/*
|
|
as an example with git,
|
|
completion table should be structured like:
|
|
{
|
|
{
|
|
items = {
|
|
'add',
|
|
'clone',
|
|
'init'
|
|
},
|
|
type = 'grid'
|
|
},
|
|
{
|
|
items = {
|
|
'-c',
|
|
'--git-dir'
|
|
},
|
|
type = 'list'
|
|
}
|
|
}
|
|
^ a table of completion groups.
|
|
it is the responsibility of the completer
|
|
to work on subcommands and subcompletions
|
|
*/
|
|
if cmpTbl, ok := luacompleteTable.TryTable(); ok {
|
|
nextVal := rt.NilValue
|
|
for {
|
|
next, val, ok := cmpTbl.Next(nextVal)
|
|
if next == rt.NilValue {
|
|
break
|
|
}
|
|
nextVal = next
|
|
|
|
_, ok = next.TryInt()
|
|
valTbl, okk := val.TryTable()
|
|
if !ok || !okk {
|
|
// TODO: error?
|
|
break
|
|
}
|
|
|
|
luaCompType := valTbl.Get(rt.StringValue("type"))
|
|
luaCompItems := valTbl.Get(rt.StringValue("items"))
|
|
|
|
compType, ok := luaCompType.TryString()
|
|
compItems, okk := luaCompItems.TryTable()
|
|
if !ok || !okk {
|
|
// TODO: error
|
|
break
|
|
}
|
|
|
|
var items []string
|
|
itemDescriptions := make(map[string]string)
|
|
nxVal := rt.NilValue
|
|
for {
|
|
nx, vl, _ := compItems.Next(nxVal)
|
|
if nx == rt.NilValue {
|
|
break
|
|
}
|
|
nxVal = nx
|
|
|
|
if tstr := nx.Type(); tstr == rt.StringType {
|
|
// ['--flag'] = {'description', '--flag-alias'}
|
|
nxStr, ok := nx.TryString()
|
|
vlTbl, okk := vl.TryTable()
|
|
if !ok || !okk {
|
|
// TODO: error
|
|
continue
|
|
}
|
|
items = append(items, nxStr)
|
|
itemDescription, ok := vlTbl.Get(rt.IntValue(1)).TryString()
|
|
if !ok {
|
|
// TODO: error
|
|
continue
|
|
}
|
|
itemDescriptions[nxStr] = itemDescription
|
|
} else if tstr == rt.IntType {
|
|
vlStr, okk := vl.TryString()
|
|
if !okk {
|
|
// TODO: error
|
|
continue
|
|
}
|
|
items = append(items, vlStr)
|
|
} else {
|
|
// TODO: error
|
|
continue
|
|
}
|
|
}
|
|
|
|
var dispType readline.TabDisplayType
|
|
switch compType {
|
|
case "grid": dispType = readline.TabDisplayGrid
|
|
case "list": dispType = readline.TabDisplayList
|
|
// need special cases, will implement later
|
|
//case "map": dispType = readline.TabDisplayMap
|
|
}
|
|
|
|
compGroup = append(compGroup, &readline.CompletionGroup{
|
|
DisplayType: dispType,
|
|
Descriptions: itemDescriptions,
|
|
Suggestions: items,
|
|
TrimSlash: false,
|
|
NoSpace: true,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(compGroup) == 0 {
|
|
completions, p := fileComplete(query, ctx, fields)
|
|
fcompGroup := []*readline.CompletionGroup{{
|
|
TrimSlash: false,
|
|
NoSpace: true,
|
|
Suggestions: completions,
|
|
}}
|
|
|
|
return p, fcompGroup
|
|
}
|
|
}
|
|
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(p string) {
|
|
halfPrompt := strings.Split(p, "\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.MultilinePrompt = ""
|
|
lr.rl.SetPrompt(p)
|
|
}
|
|
if initialized && !running {
|
|
lr.rl.RefreshPromptInPlace("")
|
|
}
|
|
}
|
|
|
|
func (lr *lineReader) SetRightPrompt(p string) {
|
|
lr.rl.SetRightPrompt(p)
|
|
if initialized && !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(rtm *rt.Runtime) *rt.Table {
|
|
lrLua := map[string]util.LuaExport{
|
|
"add": {lr.luaAddHistory, 1, false},
|
|
"all": {lr.luaAllHistory, 0, false},
|
|
"clear": {lr.luaClearHistory, 0, false},
|
|
"get": {lr.luaGetHistory, 1, false},
|
|
"size": {lr.luaSize, 0, false},
|
|
}
|
|
|
|
mod := rt.NewTable()
|
|
util.SetExports(rtm, mod, lrLua)
|
|
|
|
return mod
|
|
}
|
|
|
|
func (lr *lineReader) luaAddHistory(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
|
|
if err := c.Check1Arg(); err != nil {
|
|
return nil, err
|
|
}
|
|
cmd, err := c.StringArg(0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lr.AddHistory(cmd)
|
|
|
|
return c.Next(), nil
|
|
}
|
|
|
|
func (lr *lineReader) luaSize(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
|
|
return c.PushingNext1(t.Runtime, rt.IntValue(int64(fileHist.Len()))), nil
|
|
}
|
|
|
|
func (lr *lineReader) luaGetHistory(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
|
|
if err := c.Check1Arg(); err != nil {
|
|
return nil, err
|
|
}
|
|
idx, err := c.IntArg(0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cmd, _ := fileHist.GetLine(int(idx))
|
|
|
|
return c.PushingNext1(t.Runtime, rt.StringValue(cmd)), nil
|
|
}
|
|
|
|
func (lr *lineReader) luaAllHistory(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
|
|
tbl := rt.NewTable()
|
|
size := fileHist.Len()
|
|
|
|
for i := 1; i < size; i++ {
|
|
cmd, _ := fileHist.GetLine(i)
|
|
tbl.Set(rt.IntValue(int64(i)), rt.StringValue(cmd))
|
|
}
|
|
|
|
return c.PushingNext1(t.Runtime, rt.TableValue(tbl)), nil
|
|
}
|
|
|
|
func (lr *lineReader) luaClearHistory(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
|
|
fileHist.clear()
|
|
return c.Next(), nil
|
|
}
|