fix: correct custom runner mode handling with recent changes

with the change of blocking changes to the
hilbish table, i took an opportunity
to make the highlighter and hinter callbacks
set in a more natural way. instead of being
a function which takes a callback, you set
the function itself.

api.go

@@ -63,12 +63,29 @@ func hilbishLoad(rtm *rt.Runtime) (rt.Value, func()) {
 		return c.PushingNext1(t.Runtime, val), nil
 	}
 	modNewIndex := func(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-		k := c.Arg(1)
+		k, err := c.StringArg(1)
+		if err != nil {
+			return nil, err
+		}
+
 		v := c.Arg(2)
-		if modVal := mod.Get(k); modVal != rt.NilValue {
+		if k == "highlighter" {
+			var err error
+			// fine to assign, since itll be either nil or a closure
+			highlighter, err = c.ClosureArg(2)
+			if err != nil {
+				return nil, errors.New("hilbish.highlighter has to be a function")
+			}
+		} else if k == "hinter" {
+			var err error
+			hinter, err = c.ClosureArg(2)
+			if err != nil {
+				return nil, errors.New("hilbish.hinter has to be a function")
+			}
+		} else if modVal := mod.Get(rt.StringValue(k)); modVal != rt.NilValue {
 			return nil, errors.New("not allowed to override in hilbish table")
 		}
-		mod.Set(k, v)
+		mod.Set(rt.StringValue(k), v)
 
 		return c.Next(), nil
 	}
@@ -493,7 +510,7 @@ func hlinterval(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 // replacing <cmd> with the name of the command (for example `command.git`).
 // `cb` must be a function that returns a table of "completion groups."
 // A completion group is a table with the keys `items` and `type`.
-// `items` being a table of items and `type` being the display type of
+// `items` being a table of items and `type` being the display type, which is
 // `grid` (the normal file completion display) or `list` (with a description)
 // --- @param scope string
 // --- @param cb function
@@ -529,18 +546,27 @@ func hlprependPath(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-// which(binName)
+// which(name)
-// Searches for an executable called `binName` in the directories of $PATH
+// Checks if `name` is a valid command
 // --- @param binName string
 func hlwhich(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
 		return nil, err
 	}
-	binName, err := c.StringArg(0)
+	name, err := c.StringArg(0)
 	if err != nil {
 		return nil, err
 	}
-	path, err := exec.LookPath(binName)
+
+	cmd := aliases.Resolve(name)
+
+	// check for commander
+	if commands[cmd] != nil {
+		// they dont resolve to a path, so just send the cmd
+		return c.PushingNext1(t.Runtime, rt.StringValue(cmd)), nil
+	}
+
+	path, err := exec.LookPath(cmd)
 	if err != nil {
 		return c.Next(), nil
 	}
@@ -590,7 +616,6 @@ func hlrunnerMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	switch mode.Type() {
 		case rt.StringType:
 			switch mode.AsString() {
-				// no fallthrough doesnt work so eh
 				case "hybrid", "hybridRev", "lua", "sh": runnerMode = mode
 				default: return nil, errors.New("execMode: expected either a function or hybrid, hybridRev, lua, sh. Received " + mode.AsString())
 			}
@@ -601,40 +626,24 @@ func hlrunnerMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-// hinter(cb)
+// hinter(line, pos)
-// Sets the hinter function. This will be called on every key insert to determine
+// The command line hint handler. It gets called on every key insert to
-// what text to use as an inline hint. The callback is passed 2 arguments:
+// determine what text to use as an inline hint. It is passed the current
-// the current line and the position. It is expected to return a string
+// line and cursor position. It is expected to return a string which is used
-// which will be used for the hint.
+// as the text for the hint. This is by default a shim. To set hints,
-// --- @param cb function
+// override this function with your custom handler.
+// --- @param line string
+// --- @param pos int
 func hlhinter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.Check1Arg(); err != nil {
+	return c.Next(), nil
-		return nil, err
-	}
-	hinterCb, err := c.ClosureArg(0)
-	if err != nil {
-		return nil, err
-	}
-	hinter = hinterCb
-	
-	return c.Next(), err
 }
 
-// highlighter(cb)
+// highlighter(line)
-// Sets the highlighter function. This is mainly for syntax hightlighting, but in
+// Line highlighter handler. This is mainly for syntax highlighting, but in
-// reality could set the input of the prompt to display anything. The callback
+// reality could set the input of the prompt to *display* anything. The
-// is passed the current line as typed and is expected to return a line that will
+// callback is passed the current line and is expected to return a line that
-// be used to display in the line.
+// will be used as the input display.
-// --- @param cb function
+// --- @param line string
 func hlhighlighter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.Check1Arg(); err != nil {
+	return c.Next(), nil
-		return nil, err
-	}
-	highlighterCb, err := c.ClosureArg(0)
-	if err != nil {
-		return nil, err
-	}
-	highlighter = highlighterCb
-
-	return c.Next(), err
 }

docs/hilbish.txt

@@ -7,7 +7,7 @@ A `scope` is currently only expected to be `command.<cmd>`,
 replacing <cmd> with the name of the command (for example `command.git`).
 `cb` must be a function that returns a table of "completion groups."
 A completion group is a table with the keys `items` and `type`.
-`items` being a table of items and `type` being the display type of
+`items` being a table of items and `type` being the display type, which is
 `grid` (the normal file completion display) or `list` (with a description)
 
 cwd() > Returns the current directory of the shell
@@ -16,15 +16,16 @@ exec(cmd) > Replaces running hilbish with `cmd`
 
 goro(fn) > Puts `fn` in a goroutine
 
-highlighter(cb) > Sets the highlighter function. This is mainly for syntax hightlighting, but in
+highlighter(line) > Line highlighter handler. This is mainly for syntax highlighting, but in
-reality could set the input of the prompt to display anything. The callback
+reality could set the input of the prompt to *display* anything. The
-is passed the current line as typed and is expected to return a line that will
+callback is passed the current line and is expected to return a line that
-be used to display in the line.
+will be used as the input display.
 
-hinter(cb) > Sets the hinter function. This will be called on every key insert to determine
+hinter(line, pos) > The command line hint handler. It gets called on every key insert to
-what text to use as an inline hint. The callback is passed 2 arguments:
+determine what text to use as an inline hint. It is passed the current
-the current line and the position. It is expected to return a string
+line and cursor position. It is expected to return a string which is used
-which will be used for the hint.
+as the text for the hint. This is by default a shim. To set hints,
+override this function with your custom handler.
 
 inputMode(mode) > Sets the input mode for Hilbish's line reader. Accepts either emacs or vim
 
@@ -59,5 +60,5 @@ will call it to execute user input instead.
 timeout(cb, time) > Runs the `cb` function after `time` in milliseconds
 Returns a `timer` object (see `doc timers`).
 
-which(binName) > Searches for an executable called `binName` in the directories of $PATH
+which(name) > Checks if `name` is a valid command
 

emmyLuaDocs/hilbish.lua

@@ -16,7 +16,7 @@ function hilbish.appendPath(dir) end
 --- replacing <cmd> with the name of the command (for example `command.git`).
 --- `cb` must be a function that returns a table of "completion groups."
 --- A completion group is a table with the keys `items` and `type`.
---- `items` being a table of items and `type` being the display type of
+--- `items` being a table of items and `type` being the display type, which is
 --- `grid` (the normal file completion display) or `list` (with a description)
 --- @param scope string
 --- @param cb function
@@ -33,19 +33,21 @@ function hilbish.exec(cmd) end
 --- @param fn function
 function hilbish.goro(fn) end
 
---- Sets the highlighter function. This is mainly for syntax hightlighting, but in
+--- Line highlighter handler. This is mainly for syntax highlighting, but in
---- reality could set the input of the prompt to display anything. The callback
+--- reality could set the input of the prompt to *display* anything. The
---- is passed the current line as typed and is expected to return a line that will
+--- callback is passed the current line and is expected to return a line that
---- be used to display in the line.
+--- will be used as the input display.
---- @param cb function
+--- @param line string
-function hilbish.highlighter(cb) end
+function hilbish.highlighter(line) end
 
---- Sets the hinter function. This will be called on every key insert to determine
+--- The command line hint handler. It gets called on every key insert to
---- what text to use as an inline hint. The callback is passed 2 arguments:
+--- determine what text to use as an inline hint. It is passed the current
---- the current line and the position. It is expected to return a string
+--- line and cursor position. It is expected to return a string which is used
---- which will be used for the hint.
+--- as the text for the hint. This is by default a shim. To set hints,
---- @param cb function
+--- override this function with your custom handler.
-function hilbish.hinter(cb) end
+--- @param line string
+--- @param pos int
+function hilbish.hinter(line, pos) end
 
 --- Sets the input mode for Hilbish's line reader. Accepts either emacs or vim
 --- @param mode string
@@ -103,7 +105,7 @@ function hilbish.runnerMode(mode) end
 --- @return table
 function hilbish.timeout(cb, time) end
 
---- Searches for an executable called `binName` in the directories of $PATH
+--- Checks if `name` is a valid command
 --- @param binName string
 function hilbish.which(binName) end
 

exec.go

@@ -73,7 +73,7 @@ func runInput(input string, priv bool) {
 		}
 	} else {
 		// can only be a string or function so
-		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 2, false)
+		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 3, false)
 		err := rt.Call(l.MainThread(), runnerMode, []rt.Value{rt.StringValue(cmdString)}, term)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
@@ -81,9 +81,9 @@ func runInput(input string, priv bool) {
 			return
 		}
 
-		luaexitcode := term.Get(0)
+		luaInput := term.Get(0)
-		runErr := term.Get(1)
+		luaexitcode := term.Get(1)
-		luaInput := term.Get(1)
+		runErr := term.Get(2)
 
 		var exitCode uint8
 		if code, ok := luaexitcode.TryInt(); ok {