.github/workflows/build.yml

@@ -19,9 +19,7 @@ jobs:
             goos: windows
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v3
-        with:
-          submodules: true
+        uses: actions/checkout@v2
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
@@ -31,28 +29,10 @@ jobs:
       - uses: actions/upload-artifact@v2
         if: matrix.goos == 'windows'
         with:
-          name: hilbish-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: |
-            hilbish.exe
-            LICENSE
-            README.md
-            CHANGELOG.md
-            .hilbishrc.lua
-            nature
-            libs
-            docs
-            emmyLuaDocs
+          name: hilbish-${{ matrix.goos }}-${{ matrix.goarch }}.exe
+          path: hilbish.exe
       - uses: actions/upload-artifact@v2
         if: matrix.goos != 'windows'
         with:
           name: hilbish-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: |
-            hilbish
-            LICENSE
-            README.md
-            CHANGELOG.md
-            .hilbishrc.lua
-            nature
-            libs
-            docs
-            emmyLuaDocs
+          path: hilbish

.github/workflows/codeql-analysis.yml

@@ -1,60 +0,0 @@
-name: CodeQL
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '38 2 * * 4'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-        
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #   echo "Run, Build Application using script"
-    #   ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

.github/workflows/release.yml

@@ -30,13 +30,13 @@ jobs:
           - goarch: arm64
             goos: windows
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2
       with:
-        submodules: true
+        submodules: recursive
     - uses: wangyoucao577/go-release-action@v1.25
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
         goos: ${{ matrix.goos }}
         goarch: ${{ matrix.goarch }}
         binary_name: hilbish
-        extra_files: LICENSE README.md CHANGELOG.md .hilbishrc.lua nature libs docs emmyLuaDocs
+        extra_files: LICENSE README.md CHANGELOG.md .hilbishrc.lua prelude libs docs emmyLuaDocs

CHANGELOG.md

@@ -1,63 +1,5 @@
 # 🎀 Changelog
 
-## Unreleased
-### Added
-- Inline hints, akin to fish and the others.
-To make a handler for hint text, you can set the `hilbish.hinter` function.
-For more info, look at its docs with the `doc hilbish` command.
-- Syntax highlighting function. To make a handler for it, set
-`hilbish.highlighter`. Same thing as the hinter, check `doc hilbish` for
-more info/docs.
-- Ctrl+K deletes from the cursor to the end of the line. ([#128](https://github.com/Rosettea/Hilbish/pull/128))
-- Alt+Backspace as an alternative of Ctrl+W to delete a word. ([#132](https://github.com/Rosettea/Hilbish/pull/132))
-- Enhanced timer API (`doc timers`)
-- Don't exit until intervals are stopped/finished when running a non interactive script.
-- Ctrl+D deletes character below cursor if line isn't empty instead of exiting.
-- Ctrl+Delete to forward delete a word.
-- Right prompt ([#140](https://github.com/Rosettea/Hilbish/pull/140))
-- Ctrl+_ to undo in Emacs input mode.
-- Emacs style forward/backward word keybinds ([#139](https://github.com/Rosettea/Hilbish/pull/139))
-- `hilbish.completion.call` to call a completion handler (`doc completions`)
-- `hilbish.completion.handler` to set a custom handler for completions. This
-is for everything/anything as opposed to just adding a single command completion. 
-[#122](https://github.com/Rosettea/Hilbish/issues/122)
-- `fs.abs(path)` to get absolute path.
-- Nature module (`doc nature`)
-
-### Changed
-- **Breaking Change:** Upgraded to Lua 5.4.
-This is probably one of (if not the) biggest things in this release.
-- **Breaking Change:** MacOS config paths now match Linux.
-- Overrides on the `hilbish` table are no longer permitted.
-- **Breaking Change:** Runner functions are now required to return 3 values:
-user input, exit code, and error. User input has been added to the return to
-account for runners wanting to prompt for continued input, and to add it
-properly to history.
-
-### Fixed
-- If in Vim replace mode, input at the end of the line inserts instead of
-replacing the last character.
-- Make forward delete work how its supposed to.
-- Prompt refresh not working properly.
-- Crashing on input in xterm. ([#131](https://github.com/Rosettea/Hilbish/pull/131))
-- Make delete key work on st ([#131](https://github.com/Rosettea/Hilbish/pull/131))
-- `hilbish.login` being the wrong value.
-- Put full input in history if prompted for continued input
-- Don't put alias expanded command in history (sound familiar?)
-- Handle cases of stdin being nonblocking (in the case of [#130](https://github.com/Rosettea/Hilbish/issues/130))
-- Don't prompt for continued input if non interactive
-- Don't insert unhandled control keys.
-- Handle sh syntax error in alias
-- Use invert for completion menu selection highlight instead of specific
-colors. Brings an improvement on light themes, or themes that don't follow
-certain color rules.
-- Home/End keys now go to the actual start/end of the input.
-- Input getting cut off on enter in certain cases.
-- Go to the next line properly if input reaches end of terminal width.
-- Cursor position with CJK characters. ([#145](https://github.com/Rosettea/Hilbish/pull/145))
-- Files with same name as parent folder in completions getting cut off [#136](https://github.com/Rosettea/Hilbish/issues/136))
-- `hilbish.which` now works with commanders and aliases.
-
 ## [1.2.0] - 2022-03-17
 ### Added
 - Job Management additions

Makefile

@@ -15,7 +15,7 @@ build:
 install:
 	install -v -d "$(DESTDIR)$(BINDIR)/" && install -m 0755 -v hilbish "$(DESTDIR)$(BINDIR)/hilbish"
 	mkdir -p "$(DESTDIR)$(LIBDIR)"
-	cp -r libs docs emmyLuaDocs nature .hilbishrc.lua "$(DESTDIR)$(LIBDIR)"
+	cp -r libs docs emmyLuaDocs prelude .hilbishrc.lua "$(DESTDIR)$(LIBDIR)"
 	grep -qxF "$(DESTDIR)$(BINDIR)/hilbish" /etc/shells || echo "$(DESTDIR)$(BINDIR)/hilbish" >> /etc/shells
 
 uninstall:

aliases.go

@@ -72,7 +72,6 @@ func (a *aliasHandler) Loader(rtm *rt.Runtime) *rt.Table {
 		"add": util.LuaExport{hlalias, 2, false},
 		"list": util.LuaExport{a.luaList, 0, false},
 		"del": util.LuaExport{a.luaDelete, 1, false},
-		"resolve": util.LuaExport{a.luaResolve, 1, false},
 	}
 
 	mod := rt.NewTable()
@@ -102,16 +101,3 @@ func (a *aliasHandler) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 
 	return c.Next(), nil
 }
-
-func (a *aliasHandler) luaResolve(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.Check1Arg(); err != nil {
-		return nil, err
-	}
-	alias, err := c.StringArg(0)
-	if err != nil {
-		return nil, err
-	}
-	resolved := a.Resolve(alias)
-
-	return c.PushingNext1(t.Runtime, rt.StringValue(resolved)), nil
-}

api.go

@@ -52,47 +52,7 @@ var hilbishLoader = packagelib.Loader{
 }
 
 func hilbishLoad(rtm *rt.Runtime) (rt.Value, func()) {
-	fakeMod := rt.NewTable()
-	modmt := rt.NewTable()
 	mod := rt.NewTable()
-
-	modIndex := func(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-		arg := c.Arg(1)
-		val := mod.Get(arg)
-
-		return c.PushingNext1(t.Runtime, val), nil
-	}
-	modNewIndex := func(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-		k, err := c.StringArg(1)
-		if err != nil {
-			return nil, err
-		}
-
-		v := c.Arg(2)
-		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(rt.StringValue(k), v)
-
-		return c.Next(), nil
-	}
-	modmt.Set(rt.StringValue("__newindex"), rt.FunctionValue(rt.NewGoFunction(modNewIndex, "__newindex", 3, false)))
-	modmt.Set(rt.StringValue("__index"), rt.FunctionValue(rt.NewGoFunction(modIndex, "__index", 2, false)))
-	fakeMod.SetMetatable(modmt)
-
 	util.SetExports(rtm, mod, exports)
 	hshMod = mod
 
@@ -107,17 +67,17 @@ func hilbishLoad(rtm *rt.Runtime) (rt.Value, func()) {
 The nice lil shell for {blue}Lua{reset} fanatics!
 Check out the {blue}{bold}guide{reset} command to get started.
 `
-	util.SetFieldProtected(fakeMod, mod, "ver", rt.StringValue(version), "Hilbish version")
-	util.SetFieldProtected(fakeMod, mod, "user", rt.StringValue(username), "Username of user")
-	util.SetFieldProtected(fakeMod, mod, "host", rt.StringValue(host), "Host name of the machine")
-	util.SetFieldProtected(fakeMod, mod, "home", rt.StringValue(curuser.HomeDir), "Home directory of the user")
-	util.SetFieldProtected(fakeMod, mod, "dataDir", rt.StringValue(dataDir), "Directory for Hilbish's data files")
-	util.SetFieldProtected(fakeMod, mod, "interactive", rt.BoolValue(interactive), "If this is an interactive shell")
-	util.SetFieldProtected(fakeMod, mod, "login", rt.BoolValue(login), "Whether this is a login shell")
-	util.SetFieldProtected(fakeMod, mod, "greeting", rt.StringValue(greeting), "Hilbish's welcome message for interactive shells. It has Lunacolors formatting.")
-	util.SetFieldProtected(fakeMod, mod, "vimMode", rt.NilValue, "Current Vim mode of Hilbish (nil if not in Vim mode)")
-	util.SetFieldProtected(fakeMod, mod, "exitCode", rt.IntValue(0), "Exit code of last exected command")
-	util.Document(fakeMod, "Hilbish's core API, containing submodules and functions which relate to the shell itself.")
+	util.SetField(rtm, mod, "ver", rt.StringValue(version), "Hilbish version")
+	util.SetField(rtm, mod, "user", rt.StringValue(username), "Username of user")
+	util.SetField(rtm, mod, "host", rt.StringValue(host), "Host name of the machine")
+	util.SetField(rtm, mod, "home", rt.StringValue(curuser.HomeDir), "Home directory of the user")
+	util.SetField(rtm, mod, "dataDir", rt.StringValue(dataDir), "Directory for Hilbish's data files")
+	util.SetField(rtm, mod, "interactive", rt.BoolValue(interactive), "If this is an interactive shell")
+	util.SetField(rtm, mod, "login", rt.BoolValue(login), "Whether this is a login shell")
+	util.SetField(rtm, mod, "greeting", rt.StringValue(greeting), "Hilbish's welcome message for interactive shells. It has Lunacolors formatting.")
+	util.SetField(rtm, mod, "vimMode", rt.NilValue, "Current Vim mode of Hilbish (nil if not in Vim mode)")
+	util.SetField(rtm, hshMod, "exitCode", rt.IntValue(0), "Exit code of last exected command")
+	util.Document(mod, "Hilbish's core API, containing submodules and functions which relate to the shell itself.")
 
 	// hilbish.userDir table
 	hshuser := rt.NewTable()
@@ -149,7 +109,15 @@ Check out the {blue}{bold}guide{reset} command to get started.
 	util.Document(historyModule, "History interface for Hilbish.")
 
 	// hilbish.completion table
-	hshcomp := completionLoader(rtm)
+	hshcomp := rt.NewTable()
+	util.SetField(rtm, hshcomp, "files",
+	rt.FunctionValue(rt.NewGoFunction(luaFileComplete, "files", 3, false)),
+	"Completer for files")
+
+	util.SetField(rtm, hshcomp, "bins",
+	rt.FunctionValue(rt.NewGoFunction(luaBinaryComplete, "bins", 3, false)),
+	"Completer for executables/binaries")
+
 	util.Document(hshcomp, "Completions interface for Hilbish.")
 	mod.Set(rt.StringValue("completion"), rt.TableValue(hshcomp))
 
@@ -169,7 +137,7 @@ Check out the {blue}{bold}guide{reset} command to get started.
 	util.Document(timerModule, "Timer interface, for control of all intervals and timeouts.")
 	mod.Set(rt.StringValue("timers"), rt.TableValue(timerModule))
 
-	return rt.TableValue(fakeMod), nil
+	return rt.TableValue(mod), nil
 }
 
 func getenv(key, fallback string) string {
@@ -180,6 +148,75 @@ func getenv(key, fallback string) string {
     return value
 }
 
+func luaFileComplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	query, ctx, fds, err := getCompleteParams(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	completions, _ := fileComplete(query, ctx, fds)
+	luaComps := rt.NewTable()
+
+	for i, comp := range completions {
+		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
+	}
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(luaComps)), nil
+}
+
+func luaBinaryComplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+	query, ctx, fds, err := getCompleteParams(t, c)
+	if err != nil {
+		return nil, err
+	}
+
+	completions, _ := binaryComplete(query, ctx, fds)
+	luaComps := rt.NewTable()
+
+	for i, comp := range completions {
+		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
+	}
+
+	return c.PushingNext1(t.Runtime, rt.TableValue(luaComps)), nil
+}
+
+func getCompleteParams(t *rt.Thread, c *rt.GoCont) (string, string, []string, error) {
+	if err := c.CheckNArgs(3); err != nil {
+		return "", "", []string{}, err
+	}
+	query, err := c.StringArg(0)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+	ctx, err := c.StringArg(1)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+	fields, err := c.TableArg(2)
+	if err != nil {
+		return "", "", []string{}, err
+	}
+
+	var fds []string
+	nextVal := rt.NilValue
+	for {
+		next, val, ok := fields.Next(nextVal)
+		if next == rt.NilValue {
+			break
+		}
+		nextVal = next
+
+		valStr, ok := val.TryString()
+		if !ok {
+			continue
+		}
+
+		fds = append(fds, valStr)
+	}
+
+	return query, ctx, fds, err
+}
+
 func setVimMode(mode string) {
 	util.SetField(l, hshMod, "vimMode", rt.StringValue(mode), "Current Vim mode of Hilbish (nil if not in Vim mode)")
 	hooks.Em.Emit("hilbish.vimMode", mode)
@@ -358,11 +395,21 @@ func hlappendPath(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 
 	// check if dir is a table or a string
 	if arg.Type() == rt.TableType {
-		util.ForEach(arg.AsTable(), func(k rt.Value, v rt.Value) {
-			if v.Type() == rt.StringType {
-				appendPath(v.AsString())
+		nextVal := rt.NilValue
+		for {
+			next, val, ok := arg.AsTable().Next(nextVal)
+			if next == rt.NilValue {
+				break
+			}
+			nextVal = next
+
+			valStr, ok := val.TryString()
+			if !ok {
+				continue
+			}
+
+			appendPath(valStr)
 		}
-		})
 	} else if arg.Type() == rt.StringType {
 		appendPath(arg.AsString())
 	} else {
@@ -497,7 +544,9 @@ func hlinterval(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 // 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."
-// Check `doc completions` for more information.
+// 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
+// `grid` (the normal file completion display) or `list` (with a description)
 // --- @param scope string
 // --- @param cb function
 func hlcomplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
@@ -532,27 +581,18 @@ func hlprependPath(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-// which(name)
-// Checks if `name` is a valid command
+// which(binName)
+// Searches for an executable called `binName` in the directories of $PATH
 // --- @param binName string
 func hlwhich(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
 		return nil, err
 	}
-	name, err := c.StringArg(0)
+	binName, err := c.StringArg(0)
 	if err != nil {
 		return nil, err
 	}
-
-	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)
+	path, err := exec.LookPath(binName)
 	if err != nil {
 		return c.Next(), nil
 	}
@@ -561,7 +601,7 @@ func hlwhich(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 }
 
 // inputMode(mode)
-// Sets the input mode for Hilbish's line reader. Accepts either emacs or vim
+// Sets the input mode for Hilbish's line reader. Accepts either emacs for vim
 // --- @param mode string
 func hlinputMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
@@ -602,6 +642,7 @@ 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())
 			}
@@ -612,24 +653,40 @@ func hlrunnerMode(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-// hinter(line, pos)
-// The command line hint handler. It gets called on every key insert to
-// determine what text to use as an inline hint. It is passed the current
-// line and cursor position. It is expected to return a string which is used
-// as the text for the hint. This is by default a shim. To set hints,
-// override this function with your custom handler.
-// --- @param line string
-// --- @param pos int
+// hinter(cb)
+// Sets the hinter function. This will be called on every key insert to determine
+// what text to use as an inline hint. The callback is passed 2 arguments:
+// the current line and the position. It is expected to return a string
+// which will be used for the hint.
+// --- @param cb function
 func hlhinter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	return c.Next(), nil
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	hinterCb, err := c.ClosureArg(0)
+	if err != nil {
+		return nil, err
+	}
+	hinter = hinterCb
+	
+	return c.Next(), err
 }
 
-// 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 is passed the current line and is expected to return a line that
-// will be used as the input display.
-// --- @param line string
+// highlighter(cb)
+// Sets the highlighter function. This is mainly for syntax hightlighting, but in
+// reality could set the input of the prompt to display anything. The callback
+// is passed the current line as typed and is expected to return a line that will
+// be used to display in the line.
+// --- @param cb function
 func hlhighlighter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	return c.Next(), nil
+	if err := c.Check1Arg(); err != nil {
+		return nil, err
+	}
+	highlighterCb, err := c.ClosureArg(0)
+	if err != nil {
+		return nil, err
+	}
+	highlighter = highlighterCb
+
+	return c.Next(), err
 }

complete.go

@@ -1,14 +1,9 @@
 package main
 
 import (
-	"errors"
 	"path/filepath"
 	"strings"
 	"os"
-
-	"hilbish/util"
-
-	rt "github.com/arnodel/golua/runtime"
 )
 
 func fileComplete(query, ctx string, fields []string) ([]string, string) {
@@ -24,7 +19,7 @@ func binaryComplete(query, ctx string, fields []string) ([]string, string) {
 			fileCompletions, filePref := matchPath(query)
 			if len(fileCompletions) != 0 {
 				for _, f := range fileCompletions {
-					fullPath, _ := filepath.Abs(util.ExpandHome(query + strings.TrimPrefix(f, filePref)))
+					fullPath, _ := filepath.Abs(expandHome(query + strings.TrimPrefix(f, filePref)))
 					if err := findExecutable(fullPath, false, true); err != nil {
 						continue
 					}
@@ -71,7 +66,7 @@ func matchPath(query string) ([]string, string) {
 	var entries []string
 	var baseName string
 
-	path, _ := filepath.Abs(util.ExpandHome(filepath.Dir(query)))
+	path, _ := filepath.Abs(expandHome(filepath.Dir(query)))
 	if string(query) == "" {
 		// filepath base below would give us "."
 		// which would cause a match of only dotfiles
@@ -117,119 +112,3 @@ func escapeFilename(fname string) string {
 	return r.Replace(fname)
 }
 
-func completionLoader(rtm *rt.Runtime) *rt.Table {
-	exports := map[string]util.LuaExport{
-		"files": {luaFileComplete, 3, false},
-		"bins": {luaBinaryComplete, 3, false},
-		"call": {callLuaCompleter, 4, false},
-		"handler": {completionHandler, 2, false},
-	}
-
-	mod := rt.NewTable()
-	util.SetExports(rtm, mod, exports)
-	
-	return mod
-}
-
-// left as a shim, might doc in the same way as hilbish functions
-func completionHandler(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	return c.Next(), nil
-}
-
-func callLuaCompleter(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.CheckNArgs(4); err != nil {
-		return nil, err
-	}
-	completer, err := c.StringArg(0)
-	if err != nil {
-		return nil, err
-	}
-	query, err := c.StringArg(1)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err := c.StringArg(2)
-	if err != nil {
-		return nil, err
-	}
-	fields, err := c.TableArg(3)
-	if err != nil {
-		return nil, err
-	}
-
-	var completecb *rt.Closure
-	var ok bool
-	if completecb, ok = luaCompletions[completer]; !ok {
-		return nil, errors.New("completer " + completer + " does not exist")
-	}
-
-	// we must keep the holy 80 cols
-	completerReturn, err := rt.Call1(l.MainThread(),
-	rt.FunctionValue(completecb), rt.StringValue(query),
-	rt.StringValue(ctx), rt.TableValue(fields))
-
-	if err != nil {
-		return nil, err
-	}
-
-	return c.PushingNext1(t.Runtime, completerReturn), nil
-}
-
-func luaFileComplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	query, ctx, fds, err := getCompleteParams(t, c)
-	if err != nil {
-		return nil, err
-	}
-
-	completions, pfx := fileComplete(query, ctx, fds)
-	luaComps := rt.NewTable()
-
-	for i, comp := range completions {
-		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
-	}
-
-	return c.PushingNext(t.Runtime, rt.TableValue(luaComps), rt.StringValue(pfx)), nil
-}
-
-func luaBinaryComplete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	query, ctx, fds, err := getCompleteParams(t, c)
-	if err != nil {
-		return nil, err
-	}
-
-	completions, pfx := binaryComplete(query, ctx, fds)
-	luaComps := rt.NewTable()
-
-	for i, comp := range completions {
-		luaComps.Set(rt.IntValue(int64(i + 1)), rt.StringValue(comp))
-	}
-
-	return c.PushingNext(t.Runtime, rt.TableValue(luaComps), rt.StringValue(pfx)), nil
-}
-
-func getCompleteParams(t *rt.Thread, c *rt.GoCont) (string, string, []string, error) {
-	if err := c.CheckNArgs(3); err != nil {
-		return "", "", []string{}, err
-	}
-	query, err := c.StringArg(0)
-	if err != nil {
-		return "", "", []string{}, err
-	}
-	ctx, err := c.StringArg(1)
-	if err != nil {
-		return "", "", []string{}, err
-	}
-	fields, err := c.TableArg(2)
-	if err != nil {
-		return "", "", []string{}, err
-	}
-
-	var fds []string
-	util.ForEach(fields, func(k rt.Value, v rt.Value) {
-		if v.Type() == rt.StringType {
-			fds = append(fds, v.AsString())
-		}
-	})
-
-	return query, ctx, fds, err
-}

docs/completions.txt

@@ -1,44 +0,0 @@
-Hilbish has a pretty good completion system. It has a nice looking menu,
-with 2 types of menus: grid (like file completions) or list.
-
-Like most parts of Hilbish, it's made to be extensible and customizable.
-The default handler for completions in general can be overwritten to provide
-more advanced completions if needed.
-
-# Completion Handler
-By default, it provides 3 things: for the first argument, binaries (with a
-plain name requested to complete, those in $PATH), files, or command
-completions. With the default completion handler, it will try to run a
-handler for the command or fallback to file completions.
-
-To overwrite it, just assign a function to `hilbish.completion.handler`
-like so:
-function hilbish.completion.handler(line, pos)
-	-- do things
-end
-It is passed 2 arguments, the entire line, and the current cursor position.
-The functions in the completion interface take 3 arguments: query, ctx,
-and fields. The `query`, which what the user is currently trying to complete,
-`ctx`, being just the entire line, and `fields` being a table of arguments.
-It's just `ctx` split up, delimited by spaces.
-It's expected to return 2 things: a table of completion groups, and a prefix.
-A completion group is defined as a table with 2 keys: `items` and `type`.
-The `items` field is just a table of items to use for completions.
-The `type` is for the completion menu type, being either `grid` or `list`.
-The prefix is what all the completions start with. It should be empty
-if the user doesn't have a query. If the beginning of the completion
-item does not match the prefix, it will be replaced and fixed properly
-in the line. It is case sensitive.
-
-If you want to overwrite the functionality of the general completion handler,
-or make your command completion have files as well (and filter them),
-then there is the `files` function, which is mentioned below.
-
-# Completion Interface
-## Functions
-- `files(query, ctx, fields)` -> table, prefix: get file completions, based
-on the user's query.
-- `bins(query, ctx, fields)` -> table, prefix: get binary/executable
-completions, based on user query.
-- `call(scope, query, ctx, fields)` -> table, prefix: call a completion handler
-with `scope`, usually being in the form of `command.<name>`

docs/fs.txt

@@ -1,5 +1,3 @@
-abs(path) > Gives an absolute version of `path`.
-
 cd(dir) > Changes directory to `dir`
 
 mkdir(name, recursive) > Makes a directory called `name`. If `recursive` is true, it will create its parent directories.

docs/hilbish.txt

@@ -6,7 +6,9 @@ complete(scope, cb) > Registers a completion handler for `scope`.
 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."
-Check `doc completions` for more information.
+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
+`grid` (the normal file completion display) or `list` (with a description)
 
 cwd() > Returns the current directory of the shell
 
@@ -14,18 +16,17 @@ exec(cmd) > Replaces running hilbish with `cmd`
 
 goro(fn) > Puts `fn` in a goroutine
 
-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 is passed the current line and is expected to return a line that
-will be used as the input display.
+highlighter(cb) > Sets the highlighter function. This is mainly for syntax hightlighting, but in
+reality could set the input of the prompt to display anything. The callback
+is passed the current line as typed and is expected to return a line that will
+be used to display in the line.
 
-hinter(line, pos) > The command line hint handler. It gets called on every key insert to
-determine what text to use as an inline hint. It is passed the current
-line and cursor position. It is expected to return a string which is used
-as the text for the hint. This is by default a shim. To set hints,
-override this function with your custom handler.
+hinter(cb) > Sets the hinter function. This will be called on every key insert to determine
+what text to use as an inline hint. The callback is passed 2 arguments:
+the current line and the position. It is expected to return a string
+which will be used for the hint.
 
-inputMode(mode) > Sets the input mode for Hilbish's line reader. Accepts either emacs or vim
+inputMode(mode) > Sets the input mode for Hilbish's line reader. Accepts either emacs for vim
 
 interval(cb, time) > Runs the `cb` function every `time` milliseconds.
 Returns a `timer` object (see `doc timers`).
@@ -58,5 +59,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(name) > Checks if `name` is a valid command
+which(binName) > Searches for an executable called `binName` in the directories of $PATH
 

docs/hooks/hilbish.txt

@@ -4,4 +4,4 @@
 `modeName` is the name of the mode changed to (can be `insert`, `normal`, `delete` or `replace`).
 
 + `hilbish.vimAction` -> actionName, args > Sent when the user does a "vim action," being something
-like yanking or pasting text. See `doc vim-mode actions` for more info.
+like yanking or pasting text. See `doc vimMode actions` for more info.

docs/nature.txt

@@ -1,13 +0,0 @@
-A bit after creation, we have the outside nature. Little plants, seeds,
-growing to their final phase: a full plant. A lot of Hilbish itself is
-written in Go, but there are parts made in Lua, being the `doc` command,
-command not executable/found hooks to print a message in the shell,
-and other things.
-
-Hilbish's Lua core module is called `nature`. It's handled after everything
-on the Go side initializes, which is what that first sentence was from.
-
-# Nature Modules
-Currently, `nature` provides 1 intended public module: `nature.dirs`.
-It is a simple API for managing recent directories and old
-current working directory.

emmyLuaDocs/fs.lua

@@ -2,10 +2,6 @@
 
 local fs = {}
 
---- Gives an absolute version of `path`.
---- @param path string
-function fs.abs(path) end
-
 --- Changes directory to `dir`
 --- @param dir string
 function fs.cd(dir) end

emmyLuaDocs/hilbish.lua

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

exec.go

@@ -25,63 +25,8 @@ import (
 )
 
 var errNotExec = errors.New("not executable")
-var errNotFound = errors.New("not found")
 var runnerMode rt.Value = rt.StringValue("hybrid")
 
-type execError struct{
-	typ string
-	cmd string
-	code int
-	colon bool
-	err error
-}
-
-func (e execError) Error() string {
-	return fmt.Sprintf("%s: %s", e.cmd, e.typ)
-}
-
-func (e execError) sprint() error {
-	sep := " "
-	if e.colon {
-		sep = ": "
-	}
-
-	return fmt.Errorf("hilbish: %s%s%s", e.cmd, sep, e.err.Error())
-}
-
-func isExecError(err error) (execError, bool) {
-	if exErr, ok := err.(execError); ok {
-		return exErr, true
-	}
-
-	fields := strings.Split(err.Error(), ": ")
-	knownTypes := []string{
-		"not-found",
-		"not-executable",
-	}
-
-	if len(fields) > 1 && contains(knownTypes, fields[1]) {
-		var colon bool
-		var e error
-		switch fields[1] {
-			case "not-found":
-				e = errNotFound
-			case "not-executable":
-				colon = true
-				e = errNotExec
-		}
-
-		return execError{
-			cmd: fields[0],
-			typ: fields[1],
-			colon: colon,
-			err: e,
-		}, true
-	}
-
-	return execError{}, false
-}
-
 func runInput(input string, priv bool) {
 	running = true
 	cmdString := aliases.Resolve(input)
@@ -98,6 +43,10 @@ func runInput(input string, priv bool) {
 					return
 				}
 				input, exitCode, err = handleSh(input)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, err)
+				}
+				cmdFinish(exitCode, input, priv)
 			case "hybridRev":
 				_, _, err = handleSh(input)
 				if err == nil {
@@ -105,25 +54,38 @@ func runInput(input string, priv bool) {
 					return
 				}
 				input, exitCode, err = handleLua(cmdString)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, err)
+				}
+				cmdFinish(exitCode, input, priv)
 			case "lua":
 				input, exitCode, err = handleLua(cmdString)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, err)
+				}
+				cmdFinish(exitCode, input, priv)
 			case "sh":
 				input, exitCode, err = handleSh(input)
+				if err != nil {
+					fmt.Fprintln(os.Stderr, err)
+				}
+				cmdFinish(exitCode, input, priv)
 		}
 	} else {
 		// can only be a string or function so
-		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 3, false)
-		err = rt.Call(l.MainThread(), runnerMode, []rt.Value{rt.StringValue(cmdString)}, term)
+		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 2, false)
+		err := rt.Call(l.MainThread(), runnerMode, []rt.Value{rt.StringValue(cmdString)}, term)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			cmdFinish(124, input, priv)
 			return
 		}
 
-		luaInput := term.Get(0)
-		luaexitcode := term.Get(1)
-		runErr := term.Get(2)
+		luaexitcode := term.Get(0)
+		runErr := term.Get(1)
+		luaInput := term.Get(1)
 
+		var exitCode uint8
 		if code, ok := luaexitcode.TryInt(); ok {
 			exitCode = uint8(code)
 		}
@@ -132,19 +94,11 @@ func runInput(input string, priv bool) {
 			input = inp
 		}
 
-		if errStr, ok := runErr.TryString(); ok {
-			err = fmt.Errorf("%s", errStr)
-		}
-	}
-
-	if err != nil {
-		if exErr, ok := isExecError(err); ok {
-			hooks.Em.Emit("command." + exErr.typ, exErr.cmd)
-			err = exErr.sprint()
-		}
-		fmt.Fprintln(os.Stderr, err)
+		if runErr != rt.NilValue {
+			fmt.Fprintln(os.Stderr, runErr)
 		}
 		cmdFinish(exitCode, input, priv)
+	}
 }
 
 func handleLua(cmdString string) (string, uint8, error) {
@@ -301,20 +255,12 @@ func execHandle(bg bool) interp.ExecHandlerFunc {
 
 		err := lookpath(args[0])
 		if err == errNotExec {
-			return execError{
-				typ: "not-executable",
-				cmd: args[0],
-				code: 126,
-				colon: true,
-				err: errNotExec,
-			}
+			hooks.Em.Emit("command.no-perm", args[0])
+			hooks.Em.Emit("command.not-executable", args[0])
+			return interp.NewExitStatus(126)
 		} else if err != nil {
-			return execError{
-				typ: "not-found",
-				cmd: args[0],
-				code: 127,
-				err: errNotFound,
-			}
+			hooks.Em.Emit("command.not-found", args[0])
+			return interp.NewExitStatus(127)
 		}
 
 		killTimeout := 2 * time.Second

golibs/fs/fs.go

@@ -1,7 +1,6 @@
 package fs
 
 import (
-	"path/filepath"
 	"strconv"
 	"os"
 	"strings"
@@ -23,14 +22,13 @@ func loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
 		"mkdir": util.LuaExport{fmkdir, 2, false},
 		"stat": util.LuaExport{fstat, 1, false},
 		"readdir": util.LuaExport{freaddir, 1, false},
-		"abs": util.LuaExport{fabs, 1, false},
 	}
 	mod := rt.NewTable()
 	util.SetExports(rtm, mod, exports)
 
 	util.Document(mod, `The fs module provides easy and simple access to
 filesystem functions and other things, and acts an
-addition to the Lua standard library's I/O and filesystem functions.`)
+addition to the Lua standard library's I/O and fs functions.`)
 
 	return rt.TableValue(mod), nil
 }
@@ -46,9 +44,8 @@ func fcd(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err != nil {
 		return nil, err
 	}
-	path = util.ExpandHome(strings.TrimSpace(path))
 
-	err = os.Chdir(path)
+	err = os.Chdir(strings.TrimSpace(path))
 	if err != nil {
 		return nil, err
 	}
@@ -64,7 +61,7 @@ func fmkdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.CheckNArgs(2); err != nil {
 		return nil, err
 	}
-	path, err := c.StringArg(0)
+	dirname, err := c.StringArg(0)
 	if err != nil {
 		return nil, err
 	}
@@ -72,7 +69,7 @@ func fmkdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err != nil {
 		return nil, err
 	}
-	path = util.ExpandHome(strings.TrimSpace(path))
+	path := strings.TrimSpace(dirname)
 
 	if recursive {
 		err = os.MkdirAll(path, 0744)
@@ -97,7 +94,6 @@ func fstat(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err != nil {
 		return nil, err
 	}
-	path = util.ExpandHome(path)
 
 	pathinfo, err := os.Stat(path)
 	if err != nil {
@@ -124,7 +120,6 @@ func freaddir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err != nil {
 		return nil, err
 	}
-	dir = util.ExpandHome(dir)
 	names := rt.NewTable()
 
 	dirEntries, err := os.ReadDir(dir)
@@ -137,21 +132,3 @@ func freaddir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 
 	return c.PushingNext1(t.Runtime, rt.TableValue(names)), nil
 }
-
-// abs(path)
-// Gives an absolute version of `path`.
-// --- @param path string
-func fabs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	path, err := c.StringArg(0)
-	if err != nil {
-		return nil, err
-	}
-	path = util.ExpandHome(path)
-
-	abspath, err := filepath.Abs(path)
-	if err != nil {
-		return nil, err
-	}
-
-	return c.PushingNext1(t.Runtime, rt.StringValue(abspath)), nil
-}

lua.go

@@ -51,16 +51,14 @@ func luaInit() {
 	// Add more paths that Lua can require from
 	err := util.DoString(l, "package.path = package.path .. " + requirePaths)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "Could not add Hilbish require paths! Libraries will be missing. This shouldn't happen.")
+		fmt.Fprintln(os.Stderr, "Could not add preload paths! Libraries will be missing. This shouldn't happen.")
 	}
 
-	err1 := util.DoFile(l, "nature/init.lua")
-	if err1 != nil {
-		err2 := util.DoFile(l, preloadPath)
-		if err2 != nil {
-			fmt.Fprintln(os.Stderr, "Missing nature module, some functionality and builtins will be missing.")
-			fmt.Fprintln(os.Stderr, "local error:", err1)
-			fmt.Fprintln(os.Stderr, "global install error:", err2)
+	err = util.DoFile(l, "prelude/init.lua")
+	if err != nil {
+		err = util.DoFile(l, preloadPath)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "Missing preload file, builtins may be missing.")
 		}
 	}
 }

main.go

@@ -56,13 +56,13 @@ func main() {
 		defaultConfDir = filepath.Join(confDir, "hilbish")
 	} else {
 		// else do ~ substitution
-		defaultConfDir = filepath.Join(util.ExpandHome(defaultConfDir), "hilbish")
+		defaultConfDir = filepath.Join(expandHome(defaultConfDir), "hilbish")
 	}
 	defaultConfPath = filepath.Join(defaultConfDir, "init.lua")
 	if defaultHistDir == "" {
 		defaultHistDir = filepath.Join(userDataDir, "hilbish")
 	} else {
-		defaultHistDir = filepath.Join(util.ExpandHome(defaultHistDir), "hilbish")
+		defaultHistDir = expandHome(defaultHistDir)
 	}
 	defaultHistPath = filepath.Join(defaultHistDir, ".hilbish-history")
 	helpflag := getopt.BoolLong("help", 'h', "Prints Hilbish flags")
@@ -273,6 +273,11 @@ func handleHistory(cmd string) {
 	// TODO: load history again (history shared between sessions like this ye)
 }
 
+func expandHome(path string) string {
+	homedir := curuser.HomeDir
+	return strings.Replace(path, "~", homedir, 1)
+}
+
 func removeDupes(slice []string) []string {
 	all := make(map[string]bool)
 	newSlice := []string{}

nature/commands/cd.lua

@@ -1,35 +0,0 @@
-local bait = require 'bait'
-local commander = require 'commander'
-local fs = require 'fs'
-local dirs = require 'nature.dirs'
-
-dirs.old = hilbish.cwd()
-commander.register('cd', function (args)
-	if #args > 1 then
-		print("cd: too many arguments")
-		return 1
-	elseif #args > 0 then
-		local path = args[1]:gsub('$%$','\0'):gsub('${([%w_]+)}', os.getenv)
-		:gsub('$([%w_]+)', os.getenv):gsub('%z','$'):gsub('^%s*(.-)%s*$', '%1')
-
-        if path == '-' then
-			path = dirs.old
-            print(path)
-        end
-        dirs.setOld(hilbish.cwd())
-		dirs.push(path)
-
-		local ok, err = pcall(function() fs.cd(path) end)
-		if not ok then
-			print(err)
-			return 1
-		end
-		bait.throw('cd', path)
-
-		return
-	end
-	fs.cd(hilbish.home)
-	bait.throw('cd', hilbish.home)
-
-	dirs.push(hilbish.home)
-end)

nature/commands/cdr.lua

@@ -1,39 +0,0 @@
-local commander = require 'commander'
-local fs = require 'fs'
-local lunacolors = require 'lunacolors'
-local dirs = require 'nature.dirs'
-
-commander.register('cdr', function(args)
-	if not args[1] then
-		print(lunacolors.format [[
-cdr: change directory to one which has been recently visied
-
-usage: cdr <index>
-
-to get a list of recent directories, use {green}{underline}cdr list{reset}]])
-		return
-	end
-
-	if args[1] == 'list' then
-		local recentDirs = dirs.recentDirs
-		if #recentDirs == 0 then
-			print 'No directories have been visited.'
-			return 1
-		end
-		print(table.concat(recentDirs, '\n'))
-		return
-	end
-
-	local index = tonumber(args[1])
-	if not index then
-		print(string.format('Received %s as index, which isn\'t a number.', index))
-		return 1
-	end
-
-	if not dirs.recent(index) then
-		print(string.format('No recent directory found at index %s.', index))
-		return 1
-	end
-
-	fs.cd(dirs.recent(index))
-end)

nature/commands/doc.lua

@@ -1,93 +0,0 @@
-local commander = require 'commander'
-local fs = require 'fs'
-local lunacolors = require 'lunacolors'
-
-commander.register('doc', function(args)
-	local moddocPath = hilbish.dataDir .. '/docs/'
-	local modDocFormat = [[
-%s
-%s
-# Functions
-]]
-
-	if #args > 0 then
-		local mod = args[1]
-
-		local f = io.open(moddocPath .. mod .. '.txt', 'rb')
-		local funcdocs = nil
-		if not f then
-			-- assume subdir
-			-- dataDir/docs/<mod>/<mod>.txt
-			moddocPath = moddocPath .. mod .. '/'
-			local subdocName = args[2]
-			if not subdocName then
-				subdocName = 'index'
-			end
-			f = io.open(moddocPath .. subdocName .. '.txt', 'rb')
-			if not f then
-				print('No documentation found for ' .. mod .. '.')
-				return
-			end
-			funcdocs = f:read '*a'
-			local moddocs = table.filter(fs.readdir(moddocPath), function(f) return f ~= 'index.txt' end)
-			local subdocs = table.map(moddocs, function(fname)
-				return lunacolors.underline(lunacolors.blue(string.gsub(fname, '.txt', '')))
-			end)
-			if subdocName == 'index' then
-				funcdocs = funcdocs .. '\nSubdocs: ' .. table.concat(subdocs, ', ')
-			end
-		end
-
-		if not funcdocs then
-			funcdocs = f:read '*a'
-		end
-		local desc = ''
-		local ok = pcall(require, mod)
-		local backtickOccurence = 0
-		local formattedFuncs = lunacolors.format(funcdocs:sub(1, #funcdocs - 1):gsub('`', function()
-			backtickOccurence = backtickOccurence + 1
-			if backtickOccurence % 2 == 0 then
-				return '{reset}'
-			else
-				return '{underline}{green}'
-			end
-		end))
-
-		if ok then
-			local props = {}
-			local propstr = ''
-			local modDesc = ''
-			local modmt = getmetatable(require(mod))
-			modDesc = modmt.__doc
-			if modmt.__docProp then
-				-- not all modules have docs for properties
-				props = table.map(modmt.__docProp, function(v, k)
-					return lunacolors.underline(lunacolors.blue(k)) .. ' > ' .. v
-				end)
-			end
-			if #props > 0 then
-				propstr = '\n# Properties\n' .. table.concat(props, '\n') .. '\n'
-			end
-			desc = string.format(modDocFormat, modDesc, propstr)
-		end
-		print(desc .. formattedFuncs)
-		f:close()
-
-		return
-	end
-	local modules = table.map(fs.readdir(moddocPath), function(f)
-		return lunacolors.underline(lunacolors.blue(string.gsub(f, '.txt', '')))
-	end)
-
-	io.write [[
-Welcome to Hilbish's doc tool! Here you can find documentation for builtin
-functions and other things.
-
-Usage: doc <section> [subdoc]
-A section is a module or a literal section and a subdoc is a subsection for it.
-
-Available sections: ]]
-	io.flush()
-
-	print(table.concat(modules, ', '))
-end)

nature/commands/exit.lua

@@ -1,7 +0,0 @@
-local bait = require 'bait'
-local commander = require 'commander'
-
-commander.register('exit', function()
-	bait.throw('hilbish.exit')
-	os.exit(0)
-end)

nature/commands/guide.lua

@@ -1,54 +0,0 @@
-local ansikit = require 'ansikit'
-local commander = require 'commander'
-
-local helpTexts = {
-[[
-Hello there! Welcome to Hilbish, the comfy and nice little shell for
-Lua users and fans. Hilbish is configured with Lua, and its
-scripts are also in Lua. It also runs both Lua and shell script when
-interactive (aka normal usage).
-]],
-[[
-What does that mean for you, the user? It means that if you prefer to
-use Lua for scripting instead of shell script but still have ordinary
-shell usage for interactive use.
-]],
-[[
-If this is your first time using Hilbish and Lua, check out the
-Programming in Lua book here: https://www.lua.org/pil
-After (or if you already know Lua) check out the doc command.
-It is an in shell tool for documentation about Hilbish provided
-functions and modules.
-]],
-[[
-If you've updated from a pre-1.0 version (0.7.1 as an example)
-you'll want to move your config from ~/.hilbishrc.lua to
-]] ..
-hilbish.userDir.config .. '/hilbish/init.lua' ..
-[[
-
-and also change all global functions (prompt, alias) to be
-in the hilbish module (hilbish.prompt, hilbish.alias as examples).
-
-And if this is your first time (most likely), you can copy a config
-from ]] .. hilbish.dataDir,
-[[
-Since 1.0 is a big release, you'll want to check the changelog
-at https://github.com/Rosettea/Hilbish/releases/tag/v1.0.0
-to find more breaking changes.
-]]
-}
-commander.register('guide', function()
-	ansikit.clear()
-	ansikit.cursorTo(0, 0)
-	for _, text in ipairs(helpTexts) do
-		print(text)
-		local out = hilbish.read('Hit enter to continue ')
-		ansikit.clear()
-		ansikit.cursorTo(0, 0)
-		if not out then
-			return
-		end
-	end
-	print 'Hope you enjoy using Hilbish!'
-end)

nature/commands/init.lua

@@ -1,6 +0,0 @@
--- Add command builtins
-require 'nature.commands.cd'
-require 'nature.commands.cdr'
-require 'nature.commands.doc'
-require 'nature.commands.exit'
-require 'nature.commands.guide'

nature/completions.lua

@@ -1,40 +0,0 @@
-function hilbish.completion.handler(line, pos)
-	if type(line) ~= 'string' then error '#1 must be a string' end
-	if type(pos) ~= 'number' then error '#2 must be a number' end
-
-	-- trim leading whitespace
-	local ctx = line:gsub('^%s*(.-)$', '%1')
-	if ctx:len() == 0 then return {}, '' end
-
-	local res = hilbish.aliases.resolve(ctx)
-	local resFields = string.split(res, ' ')
-	local fields = string.split(ctx, ' ')
-	if #fields > 1 and #resFields > 1 then
-		fields = resFields
-	end
-	local query = fields[#fields]
-
-	if #fields == 1 then
-		local comps, pfx = hilbish.completion.bins(query, ctx, fields)
-		local compGroup = {
-			items = comps,
-			type = 'grid'
-		}
-
-		return {compGroup}, pfx
-	else
-		local ok, compGroups, pfx = pcall(hilbish.completion.call,
-		'command.' .. #fields[1], query, ctx, fields)
-		if ok then
-			return compGroups, pfx
-		end
-
-		local comps, pfx = hilbish.completion.files(query, ctx, fields)
-		local compGroup = {
-			items = comps,
-			type = 'grid'
-		}
-
-		return {compGroup}, pfx
-	end
-end

nature/dirs.lua

@@ -1,75 +0,0 @@
-local fs = require 'fs'
-
-local dirs = {}
-
---- Last (current working) directory. Separate from recentDirs mainly for
---- easier use.
-dirs.old = ''
---- Table of recent directories. For use, look at public functions.
-dirs.recentDirs = {}
---- Size of the recentDirs table.
-dirs.recentSize = 10
-
---- Get (and remove) a `num` of entries from recent directories.
---- @param num number
---- @param remove boolean Whether to remove items
-function dirRecents(num, remove)
-	num = num or 1
-	local entries = {}
-
-	if #dirs.recentDirs ~= 0 then
-		for i = 1, num do
-			local idx = remove and 1 or i
-			if not dirs.recentDirs[idx] then break end
-			table.insert(entries, dirs.recentDirs[idx])
-			if remove then table.remove(dirs.recentDirs, 1) end
-		end
-	end
-
-	if #entries == 1 then
-		return entries[1]
-	end
-
-	return entries
-end
-
---- Look at `num` amount of recent directories, starting from the latest.
---- @param num? number
-function dirs.peak(num)
-	return dirRecents(num)
-end
-
---- Add `d` to the recent directories.
-function dirs.push(d)
-	dirs.recentDirs[dirs.recentSize + 1] = nil
-	if dirs.recentDirs[#dirs.recentDirs - 1] ~= d then
-		ok, d = pcall(fs.abs, d)
-		assert(ok, 'could not turn "' .. d .. '"into an absolute path')
-
-		table.insert(dirs.recentDirs, 1, d)
-	end
-end
-
---- Remove `num` amount of dirs from the recent directories.
---- @param num number
-function dirs.pop(num)
-	return dirRecents(num, true)
-end
-
---- Get entry from recent directories.
---- @param idx number
-function dirs.recent(idx)
-	return dirs.recentDirs[idx]
-end
-
---- Sets the old directory.
---- @param d string
-function dirs.setOld(d)
-	ok, d = pcall(fs.abs, d)
-	assert(ok, 'could not turn "' .. d .. '"into an absolute path')
-
-	os.setenv('OLDPWD', d)
-	dirs.old = d
-end
-
-return dirs

nature/init.lua

@@ -1,45 +0,0 @@
--- Prelude initializes everything else for our shell
-local _ = require 'succulent' -- Function additions
-
-package.path = package.path .. ';' .. hilbish.dataDir .. '/?/init.lua'
-.. ';' .. hilbish.dataDir .. '/?/?.lua'
-
-require 'nature.commands'
-require 'nature.completions'
-require 'nature.opts'
-
-local shlvl = tonumber(os.getenv 'SHLVL')
-if shlvl ~= nil then
-	os.setenv('SHLVL', tostring(shlvl + 1))
-else
-	os.setenv('SHLVL', '0')
-end
-
-do
-	local virt_G = { }
-
-	setmetatable(_G, {
-		__index = function (_, key)
-			local got_virt = virt_G[key]
-			if got_virt ~= nil then
-				return got_virt
-			end
-
-			virt_G[key] = os.getenv(key)
-			return virt_G[key]
-		end,
-
-		__newindex = function (_, key, value)
-			if type(value) == 'string' then
-				os.setenv(key, value)
-				virt_G[key] = value
-			else
-				if type(virt_G[key]) == 'string' then
-					os.setenv(key, '')
-				end
-				virt_G[key] = value
-			end
-		end,
-	})
-end
-

nature/opts/autocd.lua

@@ -1,23 +0,0 @@
-local fs = require 'fs'
-
-function cdHandle(inp)
-	local input, exit, err = hilbish.runner.lua(inp)
-
-	if not err then
-		return input, exit, err
-	end
-
-	input, exit, err = hilbish.runner.sh(inp)
-
-	if exit ~= 0 and hilbish.opts.autocd then
-		local ok, stat = pcall(fs.stat, input)
-		if ok and stat.isDir then
-			-- discard here to not append the cd, which will be in history
-			_, exit, err = hilbish.runner.sh('cd ' .. input)
-		end
-	end
-
-	return input, exit, err
-end
-
-hilbish.runner.setMode(cdHandle)

nature/opts/init.lua

@@ -1,28 +0,0 @@
-local opts = {}
-hilbish.opts = {}
-
-setmetatable(hilbish.opts, {
-	__newindex = function(_, k, v)
-		if opts[k] == nil then
-			error(string.format('opt %s does not exist', k))
-		end
-
-		opts[k] = v
-	end,
-	__index = function(_, k)
-		return opts[k]
-	end
-})
-
-local function setupOpt(name, default)
-	opts[name] = default
-	require('nature.opts.' .. name)
-end
-
-local defaultOpts = {
-	autocd = false
-}
-
-for optsName, default in pairs(defaultOpts) do
-	setupOpt(optsName, default)
-end

prelude/init.lua

@@ -0,0 +1,264 @@
+-- The preload file initializes everything else for our shell
+local ansikit = require 'ansikit'
+local bait = require 'bait'
+local commander = require 'commander'
+local fs = require 'fs'
+local lunacolors = require 'lunacolors'
+local _ = require 'succulent' -- Function additions
+local oldDir = hilbish.cwd()
+
+local shlvl = tonumber(os.getenv 'SHLVL')
+if shlvl ~= nil then os.setenv('SHLVL', tostring(shlvl + 1)) else os.setenv('SHLVL', '0') end
+
+-- Builtins
+local recentDirs = {}
+commander.register('cd', function (args)
+	if #args > 0 then
+		local path = table.concat(args, ' '):gsub('$%$','\0'):gsub('${([%w_]+)}', os.getenv)
+		:gsub('$([%w_]+)', os.getenv):gsub('%z','$'):gsub('^%s*(.-)%s*$', '%1')
+
+        if path == '-' then
+            path = oldDir
+            print(path)
+        end
+        oldDir = hilbish.cwd()
+
+		local ok, err = pcall(function() fs.cd(path) end)
+		if not ok then
+			print(err:sub(17))
+			return 1
+		end
+		bait.throw('cd', path)
+
+		-- add to table of recent dirs
+		recentDirs[11] = nil
+		if recentDirs[#recentDirs - 1] ~= path then
+			table.insert(recentDirs, 1, path)
+		end
+
+		return
+	end
+	fs.cd(hilbish.home)
+	bait.throw('cd', hilbish.home)
+
+	table.insert(recentDirs, 1, hilbish.home)
+	recentDirs[11] = nil
+end)
+
+commander.register('exit', function()
+	bait.throw('hilbish.exit')
+	os.exit(0)
+end)
+
+commander.register('doc', function(args)
+	local moddocPath = hilbish.dataDir .. '/docs/'
+	local modDocFormat = [[
+%s
+%s
+# Functions
+]]
+
+	if #args > 0 then
+		local mod = args[1]
+
+		local f = io.open(moddocPath .. mod .. '.txt', 'rb')
+		local funcdocs = nil
+		if not f then
+			-- assume subdir
+			-- dataDir/docs/<mod>/<mod>.txt
+			moddocPath = moddocPath .. mod .. '/'
+			local subdocName = args[2]
+			if not subdocName then
+				subdocName = 'index'
+			end
+			f = io.open(moddocPath .. subdocName .. '.txt', 'rb')
+			if not f then
+				print('No documentation found for ' .. mod .. '.')
+				return
+			end
+			funcdocs = f:read '*a'
+			local moddocs = table.filter(fs.readdir(moddocPath), function(f) return f ~= 'index.txt' end)
+			local subdocs = table.map(moddocs, function(fname)
+				return lunacolors.underline(lunacolors.blue(string.gsub(fname, '.txt', '')))
+			end)
+			if subdocName == 'index' then
+				funcdocs = funcdocs .. '\nSubdocs: ' .. table.concat(subdocs, ', ')
+			end
+		end
+
+		if not funcdocs then
+			funcdocs = f:read '*a'
+		end
+		local desc = ''
+		local ok = pcall(require, mod)
+		local backtickOccurence = 0
+		local formattedFuncs = lunacolors.format(funcdocs:sub(1, #funcdocs - 1):gsub('`', function()
+			backtickOccurence = backtickOccurence + 1
+			if backtickOccurence % 2 == 0 then
+				return '{reset}'
+			else
+				return '{underline}{green}'
+			end
+		end))
+
+		if ok then
+			local props = {}
+			local propstr = ''
+			local modDesc = ''
+			local modmt = getmetatable(require(mod))
+			modDesc = modmt.__doc
+			if modmt.__docProp then
+				-- not all modules have docs for properties
+				props = table.map(modmt.__docProp, function(v, k)
+					return lunacolors.underline(lunacolors.blue(k)) .. ' > ' .. v
+				end)
+			end
+			if #props > 0 then
+				propstr = '\n# Properties\n' .. table.concat(props, '\n') .. '\n'
+			end
+			desc = string.format(modDocFormat, modDesc, propstr)
+		end
+		print(desc .. formattedFuncs)
+		f:close()
+
+		return
+	end
+	local modules = table.map(fs.readdir(moddocPath), function(f)
+		return lunacolors.underline(lunacolors.blue(string.gsub(f, '.txt', '')))
+	end)
+
+	io.write [[
+Welcome to Hilbish's doc tool! Here you can find documentation for builtin
+functions and other things.
+
+Usage: doc <section> [subdoc]
+A section is a module or a literal section and a subdoc is a subsection for it.
+
+Available sections: ]]
+
+	print(table.concat(modules, ', '))
+end)
+
+local helpTexts = {
+[[
+Hello there! Welcome to Hilbish, the comfy and nice little shell for
+Lua users and fans. Hilbish is configured with Lua, and its
+scripts are also in Lua. It also runs both Lua and shell script when
+interactive (aka normal usage).
+]],
+[[
+What does that mean for you, the user? It means that if you prefer to
+use Lua for scripting instead of shell script but still have ordinary
+shell usage for interactive use.
+]],
+[[
+If this is your first time using Hilbish and Lua, check out the
+Programming in Lua book here: https://www.lua.org/pil
+After (or if you already know Lua) check out the doc command.
+It is an in shell tool for documentation about Hilbish provided
+functions and modules.
+]],
+[[
+If you've updated from a pre-1.0 version (0.7.1 as an example)
+you'll want to move your config from ~/.hilbishrc.lua to
+]] ..
+hilbish.userDir.config .. '/hilbish/init.lua' ..
+[[
+
+and also change all global functions (prompt, alias) to be
+in the hilbish module (hilbish.prompt, hilbish.alias as examples).
+
+And if this is your first time (most likely), you can copy a config
+from ]] .. hilbish.dataDir,
+[[
+Since 1.0 is a big release, you'll want to check the changelog
+at https://github.com/Rosettea/Hilbish/releases/tag/v1.0.0
+to find more breaking changes.
+]]
+}
+commander.register('guide', function()
+	ansikit.clear()
+	ansikit.cursorTo(0, 0)
+	for _, text in ipairs(helpTexts) do
+		print(text)
+		local out = hilbish.read('Hit enter to continue ')
+		ansikit.clear()
+		ansikit.cursorTo(0, 0)
+		if not out then
+			return
+		end
+	end
+	print 'Hope you enjoy using Hilbish!'
+end)
+
+do
+	local virt_G = { }
+
+	setmetatable(_G, {
+		__index = function (_, key)
+			local got_virt = virt_G[key]
+			if got_virt ~= nil then
+				return got_virt
+			end
+
+			virt_G[key] = os.getenv(key)
+			return virt_G[key]
+		end,
+
+		__newindex = function (_, key, value)
+			if type(value) == 'string' then
+				os.setenv(key, value)
+				virt_G[key] = value
+			else
+				if type(virt_G[key]) == 'string' then
+					os.setenv(key, '')
+				end
+				virt_G[key] = value
+			end
+		end,
+	})
+end
+
+commander.register('cdr', function(args)
+	if not args[1] then
+		print(lunacolors.format [[
+cdr: change directory to one which has been recently visied
+
+usage: cdr <index>
+
+to get a list of recent directories, use {green}{underline}cdr list{reset}]])
+		return
+	end
+
+	if args[1] == 'list' then
+		if #recentDirs == 0 then
+			print 'No directories have been visited.'
+			return 1
+		end
+		print(table.concat(recentDirs, '\n'))
+		return
+	end
+
+	local index = tonumber(args[1])
+	if not index then
+		print(string.format('received %s as index, which isn\'t a number', index))
+		return 1
+	end
+
+	if not recentDirs[index] then
+		print(string.format('no recent directory found at index %s', index))
+		return 1
+	end
+
+	fs.cd(recentDirs[index])
+end)
+
+-- Hook handles
+bait.catch('command.not-found', function(cmd)
+	print(string.format('hilbish: %s not found', cmd))
+end)
+
+bait.catch('command.not-executable', function(cmd)
+	print(string.format('hilbish: %s: not executable', cmd))
+end)
+

rl.go

@@ -34,7 +34,8 @@ func newLineReader(prompt string, noHist bool) *lineReader {
 			case readline.VimKeys: modeStr = "normal"
 			case readline.VimInsert: modeStr = "insert"
 			case readline.VimDelete: modeStr = "delete"
-			case readline.VimReplaceOnce, readline.VimReplaceMany: modeStr = "replace"
+			case readline.VimReplaceOnce:
+			case readline.VimReplaceMany: modeStr = "replace"
 		}
 		setVimMode(modeStr)
 	}
@@ -84,91 +85,168 @@ func newLineReader(prompt string, noHist bool) *lineReader {
 		return highlighted
 	}
 	rl.TabCompleter = func(line []rune, pos int, _ readline.DelayedTabContext) (string, []*readline.CompletionGroup) {
-		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 2, false)
-		compHandle := hshMod.Get(rt.StringValue("completion")).AsTable().Get(rt.StringValue("handler"))
-		err := rt.Call(l.MainThread(), compHandle, []rt.Value{rt.StringValue(string(line)),
-		rt.IntValue(int64(pos))}, term)
+		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))
 
-		var compGroups []*readline.CompletionGroup
 				if err != nil {
-			return "", compGroups
+					return "", compGroup
 				}
 
-		luaCompGroups := term.Get(0)
-		luaPrefix := term.Get(1)
+				/*
+					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
 
-		if luaCompGroups.Type() != rt.TableType {
-			return "", compGroups
+						_, ok = next.TryInt()
+						valTbl, okk := val.TryTable()
+						if !ok || !okk {
+							// TODO: error?
+							break
 						}
 
-		groups := luaCompGroups.AsTable()
-		// prefix is optional
-		pfx, _ := luaPrefix.TryString()
-
-		util.ForEach(groups, func(key rt.Value, val rt.Value) {
-			if key.Type() != rt.IntType || val.Type() != rt.TableType {
-				return
-			}
-
-			valTbl := val.AsTable()
 						luaCompType := valTbl.Get(rt.StringValue("type"))
 						luaCompItems := valTbl.Get(rt.StringValue("items"))
 
-			if luaCompType.Type() != rt.StringType || luaCompItems.Type() != rt.TableType {
-				return
-			}
-
-			items := []string{}
-			itemDescriptions := make(map[string]string)
-
-			util.ForEach(luaCompItems.AsTable(), func(lkey rt.Value, lval rt.Value) {
-				if keytyp := lkey.Type(); keytyp == rt.StringType {
-					// ['--flag'] = {'description', '--flag-alias'}
-					itemName, ok := lkey.TryString()
-					vlTbl, okk := lval.TryTable()
-					if !ok && !okk {
+						compType, ok := luaCompType.TryString()
+						compItems, okk := luaCompItems.TryTable()
+						if !ok || !okk {
 							// TODO: error
-						return
+							break
 						}
 
-					items = append(items, itemName)
+						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
-						return
+									continue
 								}
-					itemDescriptions[itemName] = itemDescription
-				} else if keytyp == rt.IntType {
-					vlStr, ok := lval.TryString()
-						if !ok {
+								itemDescriptions[nxStr] = itemDescription
+							} else if tstr == rt.IntType {
+								vlStr, okk := vl.TryString()
+								if !okk {
 									// TODO: error
-							return
+									continue
 								}
 								items = append(items, vlStr)
 							} else {
 								// TODO: error
-					return
+								continue
+							}
 						}
-			})
 
 						var dispType readline.TabDisplayType
-			switch luaCompType.AsString() {
+						switch compType {
 							case "grid": dispType = readline.TabDisplayGrid
 							case "list": dispType = readline.TabDisplayList
 							// need special cases, will implement later
 							//case "map": dispType = readline.TabDisplayMap
 						}
 
-			compGroups = append(compGroups, &readline.CompletionGroup{
+						compGroup = append(compGroup, &readline.CompletionGroup{
 							DisplayType: dispType,
 							Descriptions: itemDescriptions,
 							Suggestions: items,
 							TrimSlash: false,
 							NoSpace: true,
 						})
-		})
+					}
+				}
+			}
 
-		return pfx, compGroups
+			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{

util/util.go

@@ -3,9 +3,7 @@ package util
 import (
 	"bufio"
 	"io"
-	"strings"
 	"os"
-	"os/user"
 
 	rt "github.com/arnodel/golua/runtime"
 )
@@ -27,37 +25,19 @@ func Document(module *rt.Table, doc string) {
 // It is accessible via the __docProp metatable. It is a table of the names of the fields.
 func SetField(rtm *rt.Runtime, module *rt.Table, field string, value rt.Value, doc string) {
 	// TODO:    ^ rtm isnt needed, i should remove it
-	SetFieldDoc(module, field, doc)
-	module.Set(rt.StringValue(field), value)
-}
-
-// SetFieldDoc sets the __docProp metatable for a field on the
-// module.
-func SetFieldDoc(module *rt.Table, field, doc string) {
 	mt := module.Metatable()
 	
 	if mt == nil {
 		mt = rt.NewTable()
+		docProp := rt.NewTable()
+		mt.Set(rt.StringValue("__docProp"), rt.TableValue(docProp))
+
 		module.SetMetatable(mt)
 	}
-
 	docProp := mt.Get(rt.StringValue("__docProp"))
-	if docProp == rt.NilValue {
-		docPropTbl := rt.NewTable()
-		mt.Set(rt.StringValue("__docProp"), rt.TableValue(docPropTbl))
-		docProp = mt.Get(rt.StringValue("__docProp"))
-	}
 
 	docProp.AsTable().Set(rt.StringValue(field), rt.StringValue(doc))
-}
-
-// SetFieldProtected sets a field in a protected table. A protected table
-// is one which has a metatable proxy to ensure no overrides happen to it.
-// It sets the field in the table and sets the __docProp metatable on the
-// user facing table.
-func SetFieldProtected(module, realModule *rt.Table, field string, value rt.Value, doc string) {
-	SetFieldDoc(module, field, doc)
-	realModule.Set(rt.StringValue(field), value)
+	module.Set(rt.StringValue(field), value)
 }
 
 // DoString runs the code string in the Lua runtime.
@@ -138,31 +118,3 @@ func HandleStrCallback(t *rt.Thread, c *rt.GoCont) (string, *rt.Closure, error)
 
 	return name, cb, err
 }
-
-// ForEach loops through a Lua table.
-func ForEach(tbl *rt.Table, cb func(key rt.Value, val rt.Value)) {
-	nextVal := rt.NilValue
-	for {
-		key, val, _ := tbl.Next(nextVal)
-		if key == rt.NilValue {
-			break
-		}
-		nextVal = key
-
-		cb(key, val)
-	}
-}
-
-// ExpandHome expands ~ (tilde) in the path, changing it to the user home
-// directory.
-func ExpandHome(path string) string {
-	if strings.HasPrefix(path, "~") {
-		curuser, _ := user.Current()
-		homedir := curuser.HomeDir
-
-		return strings.Replace(path, "~", homedir, 1)
-	}
-
-	return path
-}
-

vars_darwin.go

@@ -15,7 +15,7 @@ var (
 	.. hilbish.userDir.config	.. '/hilbish/?/?.lua;'
 	.. hilbish.userDir.config	.. '/hilbish/?.lua'`
 	dataDir = "/usr/local/share/hilbish"
-	preloadPath = dataDir + "/nature/init.lua"
+	preloadPath = dataDir + "/prelude/init.lua"
 	sampleConfPath = dataDir + "/.hilbishrc.lua" // Path to default/sample config
 	defaultConfDir = getenv("XDG_CONFIG_HOME", "~/.config")
 )

vars_linux.go

@@ -15,7 +15,7 @@ var (
 	.. hilbish.userDir.config	.. '/hilbish/?/?.lua;'
 	.. hilbish.userDir.config	.. '/hilbish/?.lua'`
 	dataDir = "/usr/share/hilbish"
-	preloadPath = dataDir + "/nature/init.lua"
+	preloadPath = dataDir + "/prelude/init.lua"
 	sampleConfPath = dataDir + "/.hilbishrc.lua" // Path to default/sample config
 	defaultConfDir = ""
 )

vars_windows.go

@@ -9,7 +9,7 @@ var (
 	.. hilbish.userDir.config .. '\\Hilbish\\libs\\?\\?.lua;'
 	.. hilbish.userDir.config .. '\\Hilbish\\libs\\?.lua;'`
 	dataDir = "~\\Appdata\\Roaming\\Hilbish" // ~ and \ gonna cry?
-	preloadPath = dataDir + "\\nature\\init.lua"
+	preloadPath = dataDir + "\\prelude\\init.lua"
 	sampleConfPath = dataDir + "\\hilbishrc.lua" // Path to default/sample config
 	defaultConfDir = ""
 )