feat: add hilbish.vim interface (closes #114)

this is going to be a middle level interface
which brings functions for interacting
with the line editor used in hilbish

adds the following functions:
setVimRegister(reg, text) - sets text in a vim register
getVimRegister(reg) - gets text from a vim register
insert(text) - inserts text into the line
accessible via hilbish.editor

api.go

@@ -163,12 +163,17 @@ Check out the {blue}{bold}guide{reset} command to get started.
 	jobModule := jobs.loader(rtm)
 	util.Document(jobModule, "(Background) job interface.")
 	mod.Set(rt.StringValue("jobs"), rt.TableValue(jobModule))
-	
+
+	// hilbish.timers table
 	timers = newTimerHandler()
 	timerModule := timers.loader(rtm)
 	util.Document(timerModule, "Timer interface, for control of all intervals and timeouts.")
 	mod.Set(rt.StringValue("timers"), rt.TableValue(timerModule))
 
+	editorModule := editorLoader(rtm)
+	util.Document(editorModule, "")
+	mod.Set(rt.StringValue("editor"), rt.TableValue(editorModule))
+
 	return rt.TableValue(fakeMod), nil
 }
 

editor.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"hilbish/util"
+
+	rt "github.com/arnodel/golua/runtime"
+)
+
+func editorLoader(rtm *rt.Runtime) *rt.Table {
+	exports := map[string]util.LuaExport{
+		"insert": {editorInsert, 1, false},
+		"setVimRegister": {editorSetRegister, 1, false},
+		"getVimRegister": {editorGetRegister, 2, false},
+	}
+
+	mod := rt.NewTable()
+	util.SetExports(rtm, mod, exports)
+
+	return mod
+}
+
+func editorInsert(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	text, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	lr.rl.Insert(text)
+
+	return c.Next(), nil
+}
+
+func editorSetRegister(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	register, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	text, err := c.StringArg(1)
+	if err != nil {
+		return nil, err
+	}
+
+	lr.rl.SetRegisterBuf(register, []rune(text))
+
+	return c.Next(), nil
+}
+
+func editorGetRegister(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+
+	register, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	buf := lr.rl.GetFromRegister(register)
+
+	return c.PushingNext1(t.Runtime, rt.StringValue(string(buf))), nil
+}

exec.go

@@ -362,12 +362,9 @@ func execHandle(bg bool) interp.ExecHandlerFunc {
 		if bg {
 			j = jobs.getLatest()
 			j.setHandle(cmd.Process)
+			j.start(cmd.Process.Pid)
 		}
 		if err == nil {
-			if bg {
-				j.start(cmd.Process.Pid)
-			}
-
 			if done := ctx.Done(); done != nil {
 				go func() {
 					<-done

job.go

@@ -59,6 +59,7 @@ func (j *job) lua() rt.Value {
 func (j *job) luaStop(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if j.running {
 		j.stop()
+		j.finish()
 	}
 
 	return c.Next(), nil
@@ -78,16 +79,19 @@ func newJobHandler() *jobHandler {
 	}
 }
 
-func (j *jobHandler) add(cmd string) {
+func (j *jobHandler) add(cmd string) *job {
 	j.mu.Lock()
 	defer j.mu.Unlock()
 
 	j.latestID++
-	j.jobs[j.latestID] = &job{
+	jb := &job{
 		cmd: cmd,
 		running: false,
 		id: j.latestID,
 	}
+	j.jobs[j.latestID] = jb
+
+	return jb
 }
 
 func (j *jobHandler) getLatest() *job {
@@ -101,6 +105,7 @@ func (j *jobHandler) loader(rtm *rt.Runtime) *rt.Table {
 	jobFuncs := map[string]util.LuaExport{
 		"all": {j.luaAllJobs, 0, false},
 		"get": {j.luaGetJob, 1, false},
+		"add": {j.luaAddJob, 1, false},
 	}
 
 	luaJob := rt.NewTable()
@@ -129,6 +134,23 @@ func (j *jobHandler) luaGetJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.PushingNext1(t.Runtime, job.lua()), nil
 }
 
+func (j *jobHandler) luaAddJob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	cmd, err := c.StringArg(0)
+	if err != nil {
+		return nil, err
+	}
+
+	jb := j.add(cmd)
+
+	return c.PushingNext1(t.Runtime, jb.lua()), nil
+}
+
 func (j *jobHandler) luaAllJobs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	j.mu.RLock()
 	defer j.mu.RUnlock()

nature/init.lua

@@ -7,6 +7,7 @@ package.path = package.path .. ';' .. hilbish.dataDir .. '/?/init.lua'
 require 'nature.commands'
 require 'nature.completions'
 require 'nature.opts'
+require 'nature.vim'
 
 local shlvl = tonumber(os.getenv 'SHLVL')
 if shlvl ~= nil then

nature/vim.lua

@@ -0,0 +1,19 @@
+local vim = {}
+hilbish.vim = {
+	registers = {}
+}
+
+setmetatable(hilbish.vim.registers, {
+	__newindex = function(_, k, v)
+		hilbish.editor.setVimRegister(k, v)
+	end,
+	__index = function(_, k)
+		return hilbish.editor.getVimRegister(k)
+	end
+})
+
+setmetatable(hilbish.vim, {
+	__index = function(_, k)
+		if k == 'mode' then return hilbish.vimMode end
+	end
+})

readline/line.go

@@ -107,6 +107,10 @@ func (rl *Instance) insert(r []rune) {
 	rl.updateHelpers()
 }
 
+func (rl *Instance) Insert(t string) {
+	rl.insert([]rune(t))
+}
+
 func (rl *Instance) deleteX() {
 	switch {
 	case len(rl.line) == 0:

readline/register.go

@@ -105,7 +105,10 @@ func (rl *Instance) saveToRegisterTokenize(tokeniser tokeniser, jumper func(toke
 // let the caller pass directly this buffer, yet relying on the register system to
 // determine which register will store the buffer.
 func (rl *Instance) saveBufToRegister(buffer []rune) {
+	rl.SetRegisterBuf(string(rl.registers.currentRegister), buffer)
+}
 
+func (rl *Instance) SetRegisterBuf(reg string, buffer []rune) {
 	// We must make an immutable version of the buffer first.
 	buf := string(buffer)
 
@@ -124,7 +127,7 @@ func (rl *Instance) saveBufToRegister(buffer []rune) {
 	// If there is an active register, directly give it the buffer.
 	// Check if its a numbered or lettered register, and put it in.
 	if rl.registers.onRegister {
-		num, err := strconv.Atoi(string(rl.registers.currentRegister))
+		num, err := strconv.Atoi(reg)
 		if err == nil && num < 10 {
 			rl.registers.writeNumberedRegister(num, []rune(buf), false)
 		} else if err != nil {
@@ -149,8 +152,12 @@ func (rl *Instance) pasteFromRegister() (buffer []rune) {
 	}
 	activeRegister := string(rl.registers.currentRegister)
 
-	// Else find the active register, and return its content.
-	num, err := strconv.Atoi(activeRegister)
+	return rl.GetFromRegister(activeRegister)
+}
+
+func (rl *Instance) GetFromRegister(reg string) []rune {
+	// Find the active register, and return its content.
+	num, err := strconv.Atoi(reg)
 
 	// Either from the numbered ones.
 	if err == nil {
@@ -158,20 +165,20 @@ func (rl *Instance) pasteFromRegister() (buffer []rune) {
 		if found {
 			return buf
 		}
-		return
+		return []rune{}
 	}
 	// or the lettered ones
-	buf, found := rl.registers.alpha[activeRegister]
+	buf, found := rl.registers.alpha[reg]
 	if found {
 		return buf
 	}
 	// Or the read-only ones
-	buf, found = rl.registers.ro[activeRegister]
+	buf, found = rl.registers.ro[reg]
 	if found {
 		return buf
 	}
 
-	return
+	return []rune{}
 }
 
 // setActiveRegister - The user has typed "<regiserID>, and we don't know yet