.hilbishrc.lua

@@ -3,19 +3,19 @@ ansikit = require 'ansikit'
 bait = require 'bait'
 
 function doPrompt(fail)
-	prompt(ansikit.format(
+	prompt(ansikit.text(
 		'{blue}%u {cyan}%d ' .. (fail and '{red}' or '{green}') .. '∆{reset} '
 	))
 end
 
-print(ansikit.format('Welcome {cyan}'.. os.getenv 'USER' ..
-'{reset} to {magenta}Hilbish{reset},\n' .. 
-'the nice lil shell for {blue}Lua{reset} fanatics!\n'))
-
 doPrompt()
 
-bait.catch('command.exit', function(code)
+bait.catch('command.fail', function()
-	doPrompt(code ~= 0)
+	doPrompt(true)
+end)
+
+bait.catch('command.success', function()
+	doPrompt()
 end)
 
 --hook("tab complete", function ())

libs/ansikit/init.lua

@@ -4,78 +4,13 @@
 
 local ansikit = {}
 
-ansikit.clear = function(scrollback)
+ansikit.getCSI = function (code, endc)
-	typ = (scrollback and 3 or 2)
-	return ansikit.printCSI(typ, 'J')
-end
-
-ansikit.clearFromPos = function(scrollback)
-	return ansikit.printCSI(0, 'J')
-end
-
-ansikit.clearLine = function()
-	return ansikit.printCSI(2, 'K')
-end
-
-ansikit.clearToPos = function()
-	return ansikit.printCSI(1, 'J')
-end
-
-ansikit.color256 = function(color)
-	color = (color and color or 0)
-	return ansikit.printCSI('38;5;' .. color)
-end
-
-ansikit.cursorDown = function(y)
-	y = (y and y or 1)
-	return ansikit.printCSI(y, 'B')
-end
-
-ansikit.cursorLeft = function(x)
-	x = (x and x or 1)
-	return ansikit.printCSI(x, 'D')
-end
-
--- TODO: cursorPos
--- https://github.com/Luvella/AnsiKit/blob/master/lib/index.js#L90
-
-ansikit.cursorRight = function(x)
-	x = (x and x or 1)
-	return ansikit.printCSI(x, 'C')
-end
-
-ansikit.cursorStyle = function(style)
-	style = (style and style or ansikit.underlineCursor)
-	if style > 6 or style < 1 then style = ansikit.underlineCursor end
-	
-	return ansikit.printCSI(style, ' q')
-end
-
-ansikit.cursorTo = function(x, y)
-	x, y = (x and x or 1), (y and y or 1)
-	return ansikit.printCSI(x .. ';' .. y, 'H')
-end
-
-ansikit.cursorUp = function(y)
-	y = (y and y or 1)
-	return ansikit.printCSI(y, 'A')
-end
-
-ansikit.getCode = function(code, terminate)
-	endc = (endc and endc or 'm')
-	return string.char(0x001b) .. code ..
-	(terminate and string.char(0x001b) .. '\\' or '')
-end
-
-ansikit.getCSI = function(code, endc)
 	endc = (endc and endc or 'm')
 	return string.char(0x001b) .. '[' .. code .. endc
 end
 
-ansikit.format = function(text)
+ansikit.text = function (text)
 	local colors = {
-		-- TODO: write codes manually instead of using functions
-		-- less function calls = faster ????????
 		reset = {'{reset}', ansikit.getCSI(0)},
 		bold = {'{bold}', ansikit.getCSI(1)},
 		dim = {'{dim}', ansikit.getCSI(2)},
@@ -90,22 +25,8 @@ ansikit.format = function(text)
 		yellow = {'{yellow}', ansikit.getCSI(33)},
 		blue = {'{blue}', ansikit.getCSI(34)},
 		magenta = {'{magenta}', ansikit.getCSI(35)},
-		cyan = {'{cyan}', ansikit.getCSI(36)},
+		cyan = {'{cyan}', ansikit.getCSI(36)}
-		white = {'{white}', ansikit.getCSI(37)},
+		-- TODO: Background, bright colors
-		red_bg = {'{red-bg}', ansikit.getCSI(41)},
-		green_bg = {'{green-bg}', ansikit.getCSI(42)},
-		yellow_bg = {'{green-bg}', ansikit.getCSI(43)},
-		blue_bg = {'{blue-bg}', ansikit.getCSI(44)},
-		magenta_bg = {'{magenta-bg}', ansikit.getCSI(45)},
-		cyan_bg = {'{cyan-bg}', ansikit.getCSI(46)},
-		white_bg = {'{white-bg}', ansikit.getCSI(47)},
-		gray = {'{gray}', ansikit.getCSI(90)},
-		bright_red = {'{bright-red}', ansikit.getCSI(91)},
-		bright_green = {'{bright-green}', ansikit.getCSI(92)},
-		bright_yellow = {'{bright-yellow}', ansikit.getCSI(93)},
-		bright_blue = {'{bright-blue}', ansikit.getCSI(94)},
-		bright_magenta = {'{bright-magenta}', ansikit.getCSI(95)},
-		bright_cyan = {'{bright-cyan}', ansikit.getCSI(96)}
 	}
 
 	for k, v in pairs(colors) do
@@ -115,25 +36,5 @@ ansikit.format = function(text)
 	return text
 end
 
-ansikit.print = function(text)
-	io.write(ansikit.format(text))
-	return ansikit
-end
-
-ansikit.printCode = function(code, terminate)
-	io.write(ansikit.getCode(code, terminate))
-	return ansikit
-end
-
-ansikit.printCSI = function(code, endc)
-	io.write(ansikit.getCSI(code, endc))
-	return ansikit
-end
-
-ansikit.println = function(text)
-	print(ansikit.print(text))
-	return ansikit
-end
-
 return ansikit
 

lua.go

@@ -10,22 +10,12 @@ import (
 	"github.com/yuin/gopher-lua"
 )
 
-var minimalconf = `
-ansikit = require 'ansikit'
-prompt(ansikit.format(
-		'{blue}%u {cyan}%d {green}∆{reset} '
-))
-`
-
 func LuaInit() {
 	l = lua.NewState()
 
 	l.OpenLibs()
 
-	l.SetGlobal("_ver", lua.LString(version))
-
 	l.SetGlobal("prompt", l.NewFunction(hshprompt))
-	l.SetGlobal("multiprompt", l.NewFunction(hshmlprompt))
 	l.SetGlobal("alias", l.NewFunction(hshalias))
 
 	// Add fs module to Lua
@@ -64,10 +54,7 @@ func LuaInit() {
 	// Run config
 	err = l.DoFile(homedir + "/.hilbishrc.lua")
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err,
+		panic(err)
-		"\nAn error has occured while loading your config! Falling back to minimal default config.\n")
-
-		l.DoString(minimalconf)
 	}
 }
 
@@ -77,12 +64,6 @@ func hshprompt(L *lua.LState) int {
 	return 0
 }
 
-func hshmlprompt(L *lua.LState) int {
-	multilinePrompt = L.ToString(1)
-
-	return 0
-}
-
 func hshalias(L *lua.LState) int {
 	alias := L.ToString(1)
 	source := L.ToString(2)

main.go

@@ -1,34 +1,35 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
 	"os"
 	"os/user"
 	"syscall"
 	"os/signal"
 	"strings"
-	"bufio"
 	"io"
+	"context"
 	hooks "hilbish/golibs/bait"
 
 	"github.com/akamensky/argparse"
 	"github.com/bobappleyard/readline"
 	"github.com/yuin/gopher-lua"
+	"layeh.com/gopher-luar"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
 
 )
 
-const version = "0.3.0"
+const version = "0.2.0"
 var l *lua.LState
 // User's prompt, this will get set when lua side is initialized
 var prompt string
-var multilinePrompt = "> "
-
 // Map of builtin/custom commands defined in the commander lua module
 var commands = map[string]bool{}
 // Command aliases
 var aliases = map[string]string{}
 var bait hooks.Bait
-var homedir string
 
 func main() {
 	parser := argparse.NewParser("hilbish", "A shell for lua and flower lovers")
@@ -57,7 +58,7 @@ func main() {
 	// Set $SHELL if the user wants to
 	if *setshflag { os.Setenv("SHELL", os.Args[0]) }
 
-	homedir, _ = os.UserHomeDir()
+	homedir, _ := os.UserHomeDir()
 	// If user's config doesn't exixt,
 	if _, err := os.Stat(homedir + "/.hilbishrc.lua"); os.IsNotExist(err) {
 		// Read default from current directory
@@ -86,10 +87,9 @@ func main() {
 	LuaInit()
 
 	readline.Completer = readline.FilenameCompleter
-	readline.LoadHistory(homedir + "/.hilbish-history")
 
 	for {
-		input, err := readline.String(fmtPrompt())
+		cmdString, err := readline.String(fmtPrompt())
 		if err == io.EOF {
 			// Exit if user presses ^D (ctrl + d)
 			fmt.Println("")
@@ -100,36 +100,80 @@ func main() {
 			fmt.Fprintln(os.Stderr, err)
 		}
 
-		input = strings.TrimSpace(input)
+		// I have no idea if we need this anymore
-		if len(input) == 0 { continue }
+		cmdString = strings.TrimSuffix(cmdString, "\n")
+		// First try to run user input in Lua
+		err = l.DoString(cmdString)
 
-		if strings.HasSuffix(input, "\\") {
+		if err == nil {
-			for {
+			// If it succeeds, add to history and prompt again
-				input, err = ContinuePrompt(strings.TrimSuffix(input, "\\"))
+			readline.AddHistory(cmdString)
+			bait.Em.Emit("command.success", nil)
+			continue
+		}
 
-				if err != nil || !strings.HasSuffix(input, "\\") { break }
+		// Split up the input
+		cmdArgs, cmdString := splitInput(cmdString)
+		// If there's actually no input, prompt again
+		if len(cmdArgs) == 0 { continue }
+
+		// If alias was found, use command alias
+		if aliases[cmdArgs[0]] != "" {
+			cmdString = aliases[cmdArgs[0]] + strings.Trim(cmdString, cmdArgs[0])
+			execCommand(cmdString)
+			continue
+		}
+
+		// If command is defined in Lua then run it
+		if commands[cmdArgs[0]] {
+			err := l.CallByParam(lua.P{
+				Fn: l.GetField(
+					l.GetTable(
+						l.GetGlobal("commanding"),
+						lua.LString("__commands")),
+					cmdArgs[0]),
+				NRet: 0,
+				Protect: true,
+			}, luar.New(l, cmdArgs[1:]))
+			if err != nil {
+				// TODO: dont panic
+				panic(err)
+			}
+			readline.AddHistory(cmdString)
+			continue
+		}
+
+		// Last option: use sh interpreter
+		switch cmdArgs[0] {
+		case "exit":
+			os.Exit(0)
+		default:
+			err := execCommand(cmdString)
+			if err != nil {
+				// If input is incomplete, start multiline prompting
+				if syntax.IsIncomplete(err) {
+					sb := &strings.Builder{}
+					for {
+						done := StartMultiline(cmdString, sb)
+						if done {
+							break
+						}
+					}
+				} else {
+					if code, ok := interp.IsExitStatus(err); ok {
+						if code > 0 {
+							bait.Em.Emit("command.fail", code)
+						}
+					}
+					fmt.Fprintln(os.Stderr, err)
+				}
+			} else {
+				bait.Em.Emit("command.success", nil)
 			}
 		}
-		RunInput(input)
 	}
 }
 
-func ContinuePrompt(prev string) (string, error) {
-	fmt.Print(multilinePrompt)
-
-	reader := bufio.NewReader(os.Stdin)
-
-	// TODO: use readline here?
-	cont, err := reader.ReadString('\n')
-	if err != nil {
-		fmt.Println("")
-		return "", err
-	}
-	cont = strings.TrimSpace(cont)
-
-	return prev + "\n" + strings.TrimSuffix(cont, "\n"), nil
-}
-
 // This semi cursed function formats our prompt (obviously)
 func fmtPrompt() string {
 	user, _ := user.Current()
@@ -156,6 +200,100 @@ func fmtPrompt() string {
 	return nprompt
 }
 
+func StartMultiline(prev string, sb *strings.Builder) bool {
+	// sb fromt outside is passed so we can
+	// save input from previous prompts
+	if sb.String() == "" { sb.WriteString(prev + "\n") }
+
+	fmt.Printf("... ")
+
+	reader := bufio.NewReader(os.Stdin)
+
+	cont, err := reader.ReadString('\n')
+	if err == io.EOF {
+		// Exit when ^D
+		fmt.Println("")
+		return true
+	}
+
+	sb.WriteString(cont)
+
+	err = execCommand(sb.String())
+	if err != nil && syntax.IsIncomplete(err) {
+		return false
+	}
+
+	return true 
+}
+
+func splitInput(input string) ([]string, string) {
+	// end my suffering
+	// TODO: refactor this garbage
+	quoted := false
+	startlastcmd := false
+	lastcmddone := false
+	cmdArgs := []string{}
+	sb := &strings.Builder{}
+	cmdstr := &strings.Builder{}
+	lastcmd := readline.GetHistory(readline.HistorySize() - 1)
+
+	for _, r := range input {
+		if r == '"' {
+			// start quoted input
+			// this determines if other runes are replaced
+			quoted = !quoted
+			// dont add back quotes
+			//sb.WriteRune(r)
+		} else if !quoted && r == '~' {
+			// if not in quotes and ~ is found then make it $HOME
+			sb.WriteString(os.Getenv("HOME"))
+		} else if !quoted && r == ' ' {
+			// if not quoted and there's a space then add to cmdargs
+			cmdArgs = append(cmdArgs, sb.String())
+			sb.Reset()
+		} else if !quoted && r == '^' && startlastcmd && !lastcmddone {
+			// if ^ is found, isnt in quotes and is
+			// the second occurence of the character and is
+			// the first time "^^" has been used
+			cmdstr.WriteString(lastcmd)
+			sb.WriteString(lastcmd)
+
+			startlastcmd = !startlastcmd
+			lastcmddone = !lastcmddone
+
+			continue
+		} else if !quoted && r == '^' && !lastcmddone {
+			// if ^ is found, isnt in quotes and is the
+			// first time of starting "^^"
+			startlastcmd = !startlastcmd
+			continue
+		} else {
+			sb.WriteRune(r)
+		}
+		cmdstr.WriteRune(r)
+	}
+	if sb.Len() > 0 {
+		cmdArgs = append(cmdArgs, sb.String())
+	}
+
+	readline.AddHistory(input)
+	return cmdArgs, cmdstr.String()
+}
+
+// Run command in sh interpreter
+func execCommand(cmd string) error {
+	file, err := syntax.NewParser().Parse(strings.NewReader(cmd), "")
+	if err != nil {
+		return err
+	}
+	runner, _ := interp.New(
+		interp.StdIO(os.Stdin, os.Stdout, os.Stderr),
+	)
+	err = runner.Run(context.TODO(), file)
+
+	return err
+}
+
 // do i even have to say
 func HandleSignals() {
 	c := make(chan os.Signal)

preload.lua

@@ -18,50 +18,10 @@ commander.register('cd', function (args)
 			if err == 1 then
 				print('directory does not exist')
 			end
-			bait.throw('command.exit', err)
+			bait.throw('command.fail', nil)
-		else bait.throw('command.exit', 0) end
+		else bait.throw('command.success', nil) end
 		return
 	end
 	fs.cd(os.getenv 'HOME')
-	bait.throw('command.exit', 0)
+	bait.throw('command.success', nil)
 end)
-
-commander.register('exit', function()
-	os.exit(0)
-end)
-
-do
-	local virt_G = { }
-	
-	setmetatable(_G, {
-		__index = function (self, 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 (self, 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,
-	})
-	
-	bait.catch('command.exit', function ()
-		for key, value in pairs(virt_G) do
-			if type(value) == 'string' then
-				virt_G[key] = os.getenv(key)
-			end
-		end
-	end)
-end

shell.go

@@ -1,184 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"bufio"
-	"context"
-	"io"
-	"strings"
-
-	"github.com/bobappleyard/readline"
-	"github.com/yuin/gopher-lua"
-	"layeh.com/gopher-luar"
-	"mvdan.cc/sh/v3/interp"
-	"mvdan.cc/sh/v3/syntax"
-
-)
-
-func RunInput(input string) {
-	// First try to run user input in Lua
-	err := l.DoString(input)
-
-	if err == nil {
-		// If it succeeds, add to history and prompt again
-		HandleHistory(input)
-
-		bait.Em.Emit("command.exit", 0)
-		return
-	}
-
-	cmdArgs, cmdString := splitInput(input)
-
-	// If alias was found, use command alias
-	if aliases[cmdArgs[0]] != "" {
-		cmdString = aliases[cmdArgs[0]] + strings.Trim(cmdString, cmdArgs[0])
-	}
-
-	// If command is defined in Lua then run it
-	if commands[cmdArgs[0]] {
-		err := l.CallByParam(lua.P{
-			Fn: l.GetField(
-				l.GetTable(
-					l.GetGlobal("commanding"),
-					lua.LString("__commands")),
-				cmdArgs[0]),
-			NRet: 0,
-			Protect: true,
-		}, luar.New(l, cmdArgs[1:]))
-		if err != nil {
-			fmt.Fprintln(os.Stderr,
-			"Error in command:\n\n" + err.Error())
-		}
-		if cmdArgs[0] != "exit" { HandleHistory(cmdString) }
-		return
-	}
-
-	// Last option: use sh interpreter
-	err = execCommand(cmdString)
-	if err != nil {
-		// If input is incomplete, start multiline prompting
-		if syntax.IsIncomplete(err) {
-			for {
-				cmdString, err = ContinuePrompt(strings.TrimSuffix(cmdString, "\\"))
-				if err != nil { break }
-				err = execCommand(cmdString)
-					if syntax.IsIncomplete(err) || strings.HasSuffix(input, "\\") {
-					continue
-				} else if code, ok := interp.IsExitStatus(err); ok {
-					bait.Em.Emit("command.exit", code)
-				} else if err != nil {
-					fmt.Fprintln(os.Stderr, err)
-					bait.Em.Emit("command.exit", 1)
-				}
-				break
-			}
-		} else {
-			if code, ok := interp.IsExitStatus(err); ok {
-				bait.Em.Emit("command.exit", code)
-			} else { fmt.Fprintln(os.Stderr, err) }
-		}
-	} else {
-		bait.Em.Emit("command.exit", 0)
-	}
-	HandleHistory(cmdString)
-}
-
-// Run command in sh interpreter
-func execCommand(cmd string) error {
-	file, err := syntax.NewParser().Parse(strings.NewReader(cmd), "")
-	if err != nil {
-		return err
-	}
-	runner, _ := interp.New(
-		interp.StdIO(os.Stdin, os.Stdout, os.Stderr),
-	)
-	err = runner.Run(context.TODO(), file)
-
-	return err
-}
-
-func splitInput(input string) ([]string, string) {
-	// end my suffering
-	// TODO: refactor this garbage
-	quoted := false
-	startlastcmd := false
-	lastcmddone := false
-	cmdArgs := []string{}
-	sb := &strings.Builder{}
-	cmdstr := &strings.Builder{}
-	lastcmd := readline.GetHistory(readline.HistorySize() - 1)
-
-	for _, r := range input {
-		if r == '"' {
-			// start quoted input
-			// this determines if other runes are replaced
-			quoted = !quoted
-			// dont add back quotes
-			//sb.WriteRune(r)
-		} else if !quoted && r == '~' {
-			// if not in quotes and ~ is found then make it $HOME
-			sb.WriteString(os.Getenv("HOME"))
-		} else if !quoted && r == ' ' {
-			// if not quoted and there's a space then add to cmdargs
-			cmdArgs = append(cmdArgs, sb.String())
-			sb.Reset()
-		} else if !quoted && r == '^' && startlastcmd && !lastcmddone {
-			// if ^ is found, isnt in quotes and is
-			// the second occurence of the character and is
-			// the first time "^^" has been used
-			cmdstr.WriteString(lastcmd)
-			sb.WriteString(lastcmd)
-
-			startlastcmd = !startlastcmd
-			lastcmddone = !lastcmddone
-
-			continue
-		} else if !quoted && r == '^' && !lastcmddone {
-			// if ^ is found, isnt in quotes and is the
-			// first time of starting "^^"
-			startlastcmd = !startlastcmd
-			continue
-		} else {
-			sb.WriteRune(r)
-		}
-		cmdstr.WriteRune(r)
-	}
-	if sb.Len() > 0 {
-		cmdArgs = append(cmdArgs, sb.String())
-	}
-
-	return cmdArgs, cmdstr.String()
-}
-
-func HandleHistory(cmd string) {
-	readline.AddHistory(cmd)
-	readline.SaveHistory(homedir + "/.hilbish-history")
-	// TODO: load history again (history shared between sessions like this ye)
-}
-
-func StartMultiline(prev string, sb *strings.Builder) bool {
-	// sb fromt outside is passed so we can
-	// save input from previous prompts
-	if sb.String() == "" { sb.WriteString(prev + "\n") }
-
-	fmt.Print(multilinePrompt)
-
-	reader := bufio.NewReader(os.Stdin)
-
-	cont, err := reader.ReadString('\n')
-	if err == io.EOF {
-		// Exit when ^D
-		fmt.Println("")
-		return true
-	}
-
-	sb.WriteString(cont)
-
-	err = execCommand(sb.String())
-	if err != nil && syntax.IsIncomplete(err) {
-		return false
-	}
-
-	return true
-}