remove api key

.gitignore

@@ -1 +1 @@
-./api/api.go
+/api/api.go

api/api.go

@@ -1,6 +1,7 @@
 package api
 
 func Api() string {
-	apiString := "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"
+	apiString := ""
+
 	return apiString
 }

command/command.go

@@ -6,7 +6,6 @@ import (
 	"bbash/command/cd"
 	"bbash/command/cp"
 	"bbash/command/echo"
-	"bbash/command/fritiofcommand"
 	"bbash/command/head"
 	"bbash/command/help"
 	"bbash/command/ls"
@@ -16,7 +15,6 @@ import (
 	"bbash/command/rm"
 	"bbash/command/tail"
 	"bbash/command/touch"
-	"bbash/command/whereareyou"
 	"bbash/environment"
 	"bbash/input_parser"
 	"fmt"
@@ -36,8 +34,6 @@ func Init(env *environment.Env) {
 
 func Run_command(in input_parser.Input, env *environment.Env) {
 	switch in.Instruction {
-	case "fritiofcommand":
-		fritiofcommand.Fritiof(in, env)
 	case "pwd":
 		pwd.Pwd(in, env)
 	case "echo":
@@ -64,8 +60,6 @@ func Run_command(in input_parser.Input, env *environment.Env) {
 		help.Help(in, env)
 	case "tail":
 		tail.Tail(in, env)
-	case "whereareyou":
-		whereareyou.Whereareyou(in, env)
 	case "brainrot":
 		brainrot.Brainrot(in, env)
 	default:
@@ -82,13 +76,8 @@ func run_by_path(in input_parser.Input, env *environment.Env) bool {
 		return false
 	}
 	cmd := exec.Command(instr, strings.Fields(in.Args_raw)...)
-	cmd.Stdin = os.Stdin
+	output, _ := cmd.CombinedOutput()
-	cmd.Stdout = os.Stdout
+	print(string(output))
-	if err := cmd.Run(); err != nil {
-		fmt.Println(err.Error())
-	}
-	//output, _ := cmd.CombinedOutput()
-	//print(string(output))
 	return true
 }
 

command/fritiofcommand/fritiof.go

@@ -1,12 +0,0 @@
-package fritiofcommand
-
-import (
-	"bbash/environment"
-	"bbash/input_parser"
-	"fmt"
-)
-
-func Fritiof(in input_parser.Input, _ *environment.Env) {
-	fmt.Print("Sannolikheten för läkarlinjen är mycket hög!")
-	// fritiof
-}

command/whereareyou/whereareyou.go

@@ -1,11 +0,0 @@
-package whereareyou
-
-import (
-	"bbash/environment"
-	"bbash/input_parser"
-	"fmt"
-)
-
-func Whereareyou(in input_parser.Input, env *environment.Env) {
-	fmt.Println("You're in the thick of it everybody knows!")
-}

hello

@@ -1,18 +0,0 @@
- a
- b
- c
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 9
- 9
- 9
- 9
- 9
- 9

input_parser/auto_complete.go

@@ -1,41 +1,24 @@
 package input_parser
 
-import (
-	"bbash/environment"
-	"os"
-	"strings"
-)
-
 var commandsTab []string
 var prevInput string
 var tabIndex int
-var skipCurrent bool
 
-func AutoComplete(input string, env environment.Env) string {
+func AutoComplete(input string) string {
 
-	rawInput := input
 	inputLength := len(input)
 
 	if inputLength == 0 {
 		return input
 	}
 
+	if tabIndex+2 > len(commandsTab) {
+		tabIndex = -1
+	}
+
 	if prevInput == input {
-
-		if skipCurrent {
-			return input
-		}
-
 		tabIndex = tabIndex + 1
 
-		if len(commandsTab) == 0 && tabIndex > 0 {
-			return input
-		}
-
-		if tabIndex > len(commandsTab)-1 {
-			tabIndex = 0
-		}
-
 		prevInput = commandsTab[tabIndex]
 		return commandsTab[tabIndex]
 	}
@@ -43,15 +26,11 @@ func AutoComplete(input string, env environment.Env) string {
 	prevInput = input
 	tabIndex = 0
 
-	var flagsDictionary []string
+	currentCommands := []string{
-
-	baseCommands := []string{
 		"cat",
 		"cd",
 		"cp",
 		"echo",
-		"exit",
-		"fritiofcommand",
 		"head",
 		"help",
 		"ls",
@@ -61,270 +40,31 @@ func AutoComplete(input string, env environment.Env) string {
 		"rm",
 		"tail",
 		"touch",
-		"whereareyou",
-	}
-
-	var paths []string
-
-	fs, err := os.ReadDir(env.Path)
-	if err != nil {
-		// fmt.Print(fmt.Sprintf("Error opening directory %s", env.Path))
-	}
-	for _, f := range fs {
-		// if (f.Name()[0] == '.') && !(slices.Contains(in.Flags, "a")) {
-		// 	continue
-		// } // allows for hidden directories
-		// fmt.Print(f.Name())
-		// fmt.Println()
-		paths = append(paths, f.Name())
-
-	}
-
-	skipCurrent = false
-	acceptAll := false
-
-	var autoCompleteCommands []string
-	indexField0 := ""
-	var currentIndexFields int
-	var nextAutoCompleteCommands []string
-	noMoreFlags := false
-
-	for indexFields, currentField := range strings.Fields(input) {
-
-		// print("noMoreFlags", noMoreFlags)
-
-		currentIndexFields = indexFields
-
-		if currentIndexFields == 0 {
-			autoCompleteCommands = baseCommands
-			indexField0 = currentField
-
-			// println("len(strings.Fields(input))", len(strings.Fields(input)))
-			// println("input[1:]k", input[len(input)-1:], "khej")
-			if len(strings.Fields(input)) == 1 && input[len(input)-1:] == " " {
-				currentIndexFields += 1
-				// println("den hittade mellanslag :D")
-				acceptAll = true
-
-			}
-		}
-
-		if currentIndexFields > 0 {
-			// autoCompleteCommands = baseFunctions
-			// println("currentField 1 :D", currentField)
-
-			switch indexField0 {
-			case "fritiofcommand":
-				skipCurrent = true
-			case "pwd":
-				skipCurrent = true
-			case "echo":
-				skipCurrent = true
-			case "ls":
-				autoCompleteCommands = paths
-				flagsDictionary = []string{
-					"-a", "-help",
-				}
-			case "cd":
-				autoCompleteCommands = paths
-			case "man":
-				autoCompleteCommands = baseCommands
-			case "cat":
-				autoCompleteCommands = paths
-			case "head":
-				autoCompleteCommands = paths
-				flagsDictionary = []string{
-					"-n", "-help",
-				}
-			case "touch":
-				autoCompleteCommands = paths
-			case "rm":
-				autoCompleteCommands = paths
-			case "cp":
-				autoCompleteCommands = paths
-				nextAutoCompleteCommands = paths
-			case "mv":
-				autoCompleteCommands = paths
-				nextAutoCompleteCommands = paths
-			case "help":
-				skipCurrent = true
-			case "tail":
-				autoCompleteCommands = paths
-				flagsDictionary = []string{
-					"-n", "-help",
-				}
-			case "whereareyou":
-				skipCurrent = true
-			default:
-				skipCurrent = true
-
-			}
-
-			if skipCurrent {
-				return rawInput
-			}
-
-			if currentIndexFields == 1 {
-				// print("currentFieldhär om den har - :D", currentField)
-				if strings.ContainsAny(currentField, "-") {
-					noMoreFlags = true
-				}
-			}
-
-			if len(strings.Fields(input)) == 2 && input[len(input)-1:] == " " {
-				// currentIndexFields += 1
-				// println("den hittade mellanslag 2 :D")
-				acceptAll = true
-				autoCompleteCommands = nil
-
-				if noMoreFlags {
-					skipCurrent = true
-					return rawInput
-
-				}
-
-			}
-
-		}
-
-		if currentIndexFields > 2 {
-			skipCurrent = true
-			return rawInput
-		}
-
-		if currentIndexFields == 2 && noMoreFlags {
-			skipCurrent = true
-			return rawInput
-		}
-
-		if len(strings.Fields(input)) == 2 && input[len(input)-1:] == "-" {
-			autoCompleteCommands = flagsDictionary
-
-		}
-
-		if currentIndexFields > 0 && len(autoCompleteCommands) == 0 || currentIndexFields > 0 && strings.ContainsAny(rawInput, "-") {
-			// println("currentIdexFields är 2!!")
-
-			// if len(flagsDictionary) == 0 {
-			// 	skipCurrent = true
-			// 	return rawInput
-			// }
-
-			// } else {
-			// 	println("input", input, "test", input[len(input)-1:], "slut")
-			// 	if input[len(input)-1:] == " " {
-			// 		println("acceptAll")
-			// 		acceptAll = true
-			// 	}
-			// }
-			// println("currentField 2 :D", currentField)
-			autoCompleteCommands = nextAutoCompleteCommands
-			// println("nextAutoCompleteCommands", nextAutoCompleteCommands)
-			// println("autoCompleteCommands", autoCompleteCommands)
-			if len(nextAutoCompleteCommands) == 0 {
-				// println("currentField 100 :D", currentField)
-				// if strings.ContainsAny(rawInput, "-") {
-				autoCompleteCommands = flagsDictionary
-				// print("autoCompleteCommands", autoCompleteCommands)
-
-				// if currentIndexFields == 1 {
-				// 	noMoreFlags = true
-				// }
-				// } else {
-				// if len(autoCompleteCommands) == 0 {
-				// skipCurrent = true
-				// return rawInput
-				// }
-				// break
-			}
-
-		}
-
-		if currentIndexFields > 0 {
-			input = currentField
-		}
-
-		// println("loop", indexFields)
-
-		// if strings.ContainsAny(currentField, "-") {
-
-		// }
-	}
-
-	// println("autoCompleteCOmmands", autoCompleteCommands)
-	// println("autoCompleteCOmmands", autoCompleteCommands[0])
-
-	if autoCompleteCommands == nil {
-		skipCurrent = true
-		return rawInput
-
 	}
 
 	var commandsWorking []string
 
-	// println(commandsWorking)
+	for _, currentCommand := range currentCommands {
 
-	inputLength = len(input)
+		if len(currentCommand) < inputLength {
-
-	aLength := 0
-
-	foundAutoComplete := false
-
-	for _, currentCommand := range autoCompleteCommands {
-		// println("currentCommand")
-		// println(currentCommand)
-
-		if len(currentCommand) < inputLength && !acceptAll {
 			continue
 		}
 
-		if !acceptAll {
+		currentCommandWithoutEnd := currentCommand[:inputLength]
-			currentCommandWithoutEnd := currentCommand[:inputLength]
+
-			if currentCommandWithoutEnd != input {
+		if currentCommandWithoutEnd != input {
-				continue
+			continue
-			}
-		}
-
-		foundAutoComplete = true
-
-		aLength = len(currentCommand) - len(input)
-		aLength = len(currentCommand) - aLength
-
-		// println("aLength")
-		// println(aLength)
-
-		// println("currentCommand")
-		// println(currentCommand)
-
-		// println("rawInput")
-		// println(rawInput)
-
-		if acceptAll {
-			commandsWorking = append(commandsWorking, rawInput+currentCommand)
-		} else {
-			commandsWorking = append(commandsWorking, rawInput+currentCommand[aLength:])
 		}
 
+		commandsWorking = append(commandsWorking, currentCommand)
 	}
 
-	if !foundAutoComplete {
-		skipCurrent = true
-		return rawInput
-	}
-
-	// println("commandsWorking")
-	// println(commandsWorking[0])
-	// println(commandsWorking[1])
-
 	commandsTab = commandsWorking
 
 	if len(commandsTab) == 0 {
 		return input
 	}
 
-	removedStart := commandsTab[0]
+	prevInput = commandsTab[0]
-	// removedStart := commandsTab[0][inputLength:]
+	return commandsTab[0]
-
-	prevInput = removedStart
-	return prevInput
 }

input_parser/auto_complete_history.go

@@ -1,55 +0,0 @@
-package input_parser
-
-import "bbash/environment"
-
-func AutoCompleteHistory(input string, env environment.Env) string {
-
-	inputLength := len(input)
-
-	if inputLength == 0 {
-		return ""
-	}
-
-	// tabIndex = 0
-
-	// currentCommands := []string{
-	// 	"cat",
-	// 	"cd",
-	// 	"cp",
-	// 	"echo",
-	// 	"head",
-	// 	"help",
-	// 	"ls",
-	// 	"man",
-	// 	"mv",
-	// 	"pwd",
-	// 	"rm",
-	// 	"tail",
-	// 	"touch",
-	// }
-
-	historyWorking := ""
-
-	for _, currentHistory := range env.History[:len(env.History)-1] {
-		// println("currentHistory", currentHistory)
-
-		if len(currentHistory) < inputLength {
-			continue
-		}
-
-		currentCommandWithoutEnd := currentHistory[:inputLength]
-
-		if currentCommandWithoutEnd != input {
-			continue
-		}
-
-		historyWorking = currentHistory
-
-	}
-
-	if len(historyWorking) != 0 {
-		historyWorking = historyWorking[inputLength:]
-	}
-
-	return historyWorking
-}

input_parser/escape_handler.go

@@ -1,105 +0,0 @@
-package input_parser
-
-import (
-	"bbash/environment"
-	"bufio"
-	"fmt"
-	"strings"
-)
-
-func Escape_handler(reader *bufio.Reader, history_index int, input string, env environment.Env, cursor int) (string, int, int) {
-	next_rune, _, _ := reader.ReadRune()
-	if next_rune == 59 {
-	}
-	if next_rune != 91 { // not "["
-		return "", history_index, cursor
-	}
-	next_rune, _, _ = reader.ReadRune()
-
-	switch next_rune {
-	case 65: //A
-		if history_index > 0 {
-			history_index--
-			input = env.History[history_index]
-			cursor = len(input)
-		}
-	case 66: //B
-		if history_index < len(env.History)-1 {
-			history_index++
-			input = env.History[history_index]
-		}
-		if history_index == len(env.History)-1 {
-			input = ""
-			cursor = 0
-		}
-		cursor = len(input)
-	case 68: //D
-		if cursor > 0 {
-			cursor--
-		}
-
-	case 67: //C
-		if prevGhostString != "" {
-			input = input + prevGhostString
-			cursor = len(input)
-		}
-		if cursor < len(input) {
-			cursor++
-		}
-	case 49:
-		cursor = ctrl(reader, input, cursor)
-		return input, history_index, cursor
-
-	}
-
-
-	return input, history_index, cursor
-}
-func ctrl(reader *bufio.Reader, input string, cursor int) int {
-	next_rune, _, err := reader.ReadRune()
-	if err != nil {
-		fmt.Println(err.Error())
-		return cursor
-	}
-	if next_rune != 59 {
-		return cursor
-	}
-	next_rune, _, err = reader.ReadRune()
-	if err != nil {
-		fmt.Println(err.Error())
-		return cursor
-	}
-	if next_rune != 53 {
-		return cursor
-	}
-	next_rune, _, err = reader.ReadRune()
-	if err != nil {
-		fmt.Println(err.Error())
-		return cursor
-	}
-	switch next_rune {
-	case 68: // ctrl left
-		input_at := input[:cursor]
-		last_index := strings.LastIndex(input_at, " ")
-		if last_index == -1 {
-			cursor = 0
-		} else {
-			input_at = input_at[:last_index]
-			cursor = len(input_at)
-		}
-	case 67: // ctrl right
-		input_next := input[cursor:]
-		next_trimmed := strings.TrimLeft(input_next, " ")
-		last_index := strings.Index(next_trimmed, " ")
-		if last_index == -1 {
-			cursor = len(input)
-		} else {
-			cursor = cursor + last_index + (len(input_next) - len(next_trimmed))
-		}
-	}
-	return cursor
-	
-
-
-}
-

input_parser/input_parser.go

@@ -10,8 +10,6 @@ import (
 	"golang.org/x/term"
 )
 
-var prevGhostString string
-
 type Input struct {
 	// The instruction a.k.a first argument
 	Instruction string
@@ -24,10 +22,10 @@ type Input struct {
 
 func Parse(env *environment.Env) Input {
 	input := input_str(env)
-	return Parse_input(input)
+	return parse_input(input)
 }
-func Parse_input(input string) Input {
+func parse_input(input string) Input {
-	split := strings.Split(strings.TrimSpace(string(input)), " ")
+	split := strings.Split(string(input), " ")
 	instruction := strings.TrimSpace(split[0])
 
 	args_raw := ""
@@ -38,11 +36,14 @@ func Parse_input(input string) Input {
 	var flags []string
 	var args []string
 	for _, arg := range split[1:] {
-		if len(arg) == 1 {
+		if len(arg) == 0 {
+			continue
+		} else if len(arg) == 1 {
 			if arg[0] == '-' {
 				continue
+			} else {
+				args = append(args, strings.TrimSpace(arg))
 			}
-			_ = append(args, string(arg[0]))
 		} else if arg[0:2] == "--" {
 			var result = strings.TrimSpace(arg)
 			flags = append(flags, string(result[2:]))
@@ -77,8 +78,6 @@ func input_str(env *environment.Env) string {
 	history_index := len(env.History) // not -1 since we start at the new one
 	env.History = append(env.History, input)
 
-	cursor := 0
-
 	env.History[len(env.History)-1] = input
 	fmt.Print("\r\033[K")
 	fmt.Print(env.Path)
@@ -86,82 +85,54 @@ func input_str(env *environment.Env) string {
 	fmt.Print(input)
 
 	for {
-		if cursor > len(input) {
-			cursor = len(input)
-		}
-		if cursor < 0 {
-			cursor = 0
-		}
 		r_rune, _, err := reader.ReadRune()
 		if err != nil {
-			fmt.Print(fmt.Sprintf("Error reading user input: %s", err.Error()))
+			fmt.Print(fmt.Sprintf("Error reading user input: ", err.Error()))
 		}
 		switch r_rune {
 		case 3: // ^C
 			fmt.Println("^C")
-			cursor = 0
 			input = ""
 		case 4: // ^D
 			input = "exit"
 			goto loop_exit
-		case 8:  // <CTR><BACKSPACE>
+		case 9: // Tab
-			input_at := input[:cursor]
+			input = AutoComplete(input)
-			input_after := input[cursor:]
+		case 91:
-			last_index := strings.LastIndex(input_at, " ")
+			if r, _, _ := reader.ReadRune(); r == 65 { // UPP
-			if last_index == -1 {
+				if history_index > 0 {
-				input_at = ""
+					history_index--
-				cursor = 0
+					input = env.History[history_index]
-			} else {
+				}
-				input_at = input_at[:last_index]
+				break
-				cursor = len(input_at)
+
 			}
-			input = input_at+input_after
+			if r, _, _ := reader.ReadRune(); r != 66 { //DOWN
-		
+				if history_index < len(env.History)-2 {
-		case 9: // TAB
+					history_index++
-			input = AutoComplete(input, *env)
+					input = env.History[history_index]
-			cursor = len(input)
+				} else {
-		case 27: // Escape
+					input = ""
-			input, history_index, cursor = Escape_handler(reader, history_index, input, *env, cursor)
+				}
+				break
+			}
+
 		case 127: //packspace
-			input_at := input[:cursor]
-			input_after := input[cursor:]
 			if len(input) > 0 {
-				input_at = input_at[:len(input_at)-1]
+				input = input[:len(input)-1]
-				cursor--
 			}
-			input=input_at+input_after
 		case 13: // Enter
 			goto loop_exit
 		default:
-			input_at := input[:cursor]
+			input = input + string(r_rune)
-			input_after := input[cursor:]
-			input_at += string(r_rune)
-			input = input_at+input_after
-			cursor++
 		}
-		ghost_input := AutoCompleteHistory(input, *env)
-
 		env.History[len(env.History)-1] = input
 		fmt.Print("\r")
-		fmt.Print(env.Path)
+		fmt.Print("\r\033[K")
-		fmt.Print(" > \033[K")
-		fmt.Print(input)
-		fmt.Print("\033[2m", ghost_input, "\033[0m")
-
-		prevGhostString = ""
-
-		backwardSteps := len(ghost_input)
-		if backwardSteps != 0 {
-			fmt.Printf("\033[%dD", backwardSteps)
-			prevGhostString = ghost_input
-		}
-		fmt.Print("\r")
 		fmt.Print(env.Path)
 		fmt.Print(" > ")
-		for i := 0; i < cursor; i++ {
+		fmt.Print("\033[K")
-			fmt.Print("\033[C")
+		fmt.Print(input)
-		}
-
 	}
 loop_exit:
 	term.Restore(int(std_fd), term_restore)