README.md

@@ -110,11 +110,10 @@ go build -o "dist/ads" "code/golang/main.go";
 ```
 und dann mit dem gebauten Artefakt arbeiten:
 ```bash
-dist/ads # (bzw. Doppelklick auf Datei) startet Programm im interaktiven Modus
-dist/ads help; # zeigt Hilfsanleitung
-dist/ads version; # zeigt Version
-dist/ads run [--debug]; # Algorithmus auf Fälle in code/config.yml ausführen
-dist/ads run [--debug] --it;  # startet Programm im interaktiven Modus
+./dist/ads help; # zeigt Hilfsanleitung
+./dist/ads version; # zeigt Version
+./dist/ads run [--debug]; # Algorithmus auf Fälle in code/config.yml ausführen
+./dist/ads run [--debug] --it;  # startet Programm im interaktiven Modus
 ## NOTE: --debug Option = Infos über Schritte zeigen
 ```
 

code/golang/internal/algorithms/sum/maxsubsum/maxsubsum_fancy.go

@@ -1,9 +1,5 @@
 package maxsubsum
 
-/* ---------------------------------------------------------------- *
- * IMPORTS
- * ---------------------------------------------------------------- */
-
 import (
 	"fmt"
 
@@ -11,6 +7,10 @@ import (
 	"ads/internal/setup"
 )
 
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
 /* ---------------------------------------------------------------- *
  * GLOBAL VARIABLES/CONSTANTS
  * ---------------------------------------------------------------- */

code/golang/internal/core/logging/logging.go

@@ -26,7 +26,6 @@ var ansimode bool = true
 var loggingPrefix string = ""
 var force bool = false
 var tagAll bool = false
-var promptSymb string = ">"
 
 func GetQuietMode() bool {
 	return quietmode
@@ -132,7 +131,7 @@ func Prompt(lines ...interface{}) (string, bool, error) {
 		logGeneric(pipe, "", lines...)
 		logGeneric(pipe, "", "")
 	}
-	fmt.Fprintf(pipe, "%s ", promptSymb)
+	fmt.Fprint(pipe, "$ ")
 	reader := bufio.NewReader(os.Stdin)
 	line, err := reader.ReadString('\n')
 	line = re.Sub(`\s+$`, "", line)

code/golang/internal/endpoints/endpoints_it.go

@@ -5,8 +5,6 @@ package endpoints
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/menus"
 	"ads/internal/setup"
@@ -42,74 +40,22 @@ var menuMain = menus.Menu{
 	PromptMessages: []string{
 		"Option wählen",
 	},
-	Options: [][]menus.MenuOption{
-		{
-			{Label: "Einstellungen", Submenu: &menuSettings},
+	Options: []menus.MenuOption{
 		{Label: "Version des Programms anzeigen", Action: actionShowVersion},
-		}, {
 		{Label: "Programm auf config Datei ausführen.", Action: actionRunOnConfig},
-		}, {
 		{Label: "Suchalgorithmen", Submenu: &menuSearchAlgorithms},
 		{Label: "Summenalgorithmen", Submenu: &menuSumAlgorithms},
 	},
-	},
-	Default: -1,
-}
-
-var menuSettings = menus.Menu{
-	Path: []string{"Hauptmenü", "Einstellungen"},
-	PromptMessages: []string{
-		"Option wählen",
-	},
-	Options: [][]menus.MenuOption{
-		{
-			{Label: "Aktueller Zustand", Action: actionShowSettings},
-			{Label: "Farbenmodus", Submenu: &menuColourMode},
-			{Label: "Debugmodus", Submenu: &menuDebugMode},
-		},
-	},
-	Default: -1,
-}
-
-var menuColourMode = menus.Menu{
-	ForceReturn: true,
-	Path:        []string{"Hauptmenü", "Einstellungen", "Farbenmodus"},
-	PromptMessages: []string{
-		"Soll Console-Output mit Formattierung dargestellt werden?",
-		"Option für den Farbenmodus wählen:",
-	},
-	Options: [][]menus.MenuOption{
-		{
-			{Label: "ein", Action: actionColourModeOn},
-			{Label: "aus", Action: actionColourModeOff},
-		},
-	},
-	Default: 0,
-}
-
-var menuDebugMode = menus.Menu{
-	ForceReturn: true,
-	Path:        []string{"Hauptmenü", "Einstellungen", "Debugmodus"},
-	PromptMessages: []string{
-		"Sollen Infos zu jedem Schritt der Algorithmen angezeigt werden?",
-		"Option für den Debugmodus wählen:",
-	},
-	Options: [][]menus.MenuOption{
-		{
-			{Label: "ein", Action: actionDebugModeOn},
-			{Label: "aus", Action: actionDebugModeOff},
-		},
-	},
-	Default: 1,
+	DefaultOption: -1,
 }
 
 var menuSearchAlgorithms = menus.Menu{
-	Path: []string{"Hauptmenü", "Suchalgorithmen"},
+	IsRoot: false,
+	Path:   []string{"Hauptmenü", "Suchalgorithmus"},
 	PromptMessages: []string{
 		"Algorithmus wählen",
 	},
-	Options: [][]menus.MenuOption{
-		{
+	Options: []menus.MenuOption{
 		{Label: "Binärsuchalgorithmus", Action: actionAlgorithmSearchBinary},
 		{Label: "Interpolationsalgorithmus", Action: actionAlgorithmSearchInterpolation},
 		{Label: "Suche i. kleinstes Element", Action: actionAlgorithmSearchIthElement},
@@ -120,22 +66,20 @@ var menuSearchAlgorithms = menus.Menu{
 		{Label: "Giftsuche", SubLabel: "optimiert", Action: actionAlgorithmSearchPoisonFast},
 		{Label: "Sequentiellsuchalgorithmus", Action: actionAlgorithmSearchSequential},
 	},
-	},
-	Default: -1,
+	DefaultOption: -1,
 }
 
 var menuSumAlgorithms = menus.Menu{
-	Path: []string{"Hauptmenü", "Summenalgorithmen"},
+	IsRoot: false,
+	Path:   []string{"Hauptmenü", "Suchalgorithmus"},
 	PromptMessages: []string{
 		"Algorithmus wählen",
 	},
-	Options: [][]menus.MenuOption{
-		{
+	Options: []menus.MenuOption{
 		{Label: "Maximale Teilsumme", SubLabel: "brute force", Action: actionAlgorithmSumMaxsub},
 		{Label: "Maximale Teilsumme", SubLabel: "D & C", Action: actionAlgorithmSumMaxsubDc},
 	},
-	},
-	Default: -1,
+	DefaultOption: -1,
 }
 
 /* ---------------------------------------------------------------- *
@@ -148,41 +92,6 @@ func actionShowVersion() (bool, error) {
 	return false, nil
 }
 
-func actionShowSettings() (bool, error) {
-	var state string
-	state = "aus"
-	if logging.GetAnsiMode() {
-		state = "ein"
-	}
-	logging.LogInfo(fmt.Sprintf("Farbenmodus: %s", state))
-	state = "aus"
-	if logging.GetDebugMode() {
-		state = "ein"
-	}
-	logging.LogInfo(fmt.Sprintf("Debugmodus: %s", state))
-	return false, nil
-}
-
-func actionColourModeOn() (bool, error) {
-	logging.SetAnsiMode(true)
-	return false, nil
-}
-
-func actionColourModeOff() (bool, error) {
-	logging.SetAnsiMode(false)
-	return false, nil
-}
-
-func actionDebugModeOn() (bool, error) {
-	logging.SetDebugMode(true)
-	return false, nil
-}
-
-func actionDebugModeOff() (bool, error) {
-	logging.SetDebugMode(false)
-	return false, nil
-}
-
 /* ---------------------------------------------------------------- *
  * ACTIONS - Algorithmen
  * ---------------------------------------------------------------- */

code/golang/internal/endpoints/endpoints_run.go

@@ -5,6 +5,8 @@ package endpoints
  * ---------------------------------------------------------------- */
 
 import (
+	"ads/internal/setup"
+	"ads/internal/types"
 	"fmt"
 
 	algorithm_search_binary "ads/internal/algorithms/search/binary"
@@ -15,8 +17,6 @@ import (
 	algorithm_search_sequential "ads/internal/algorithms/search/sequential"
 	algorithm_sum_maxsubsum "ads/internal/algorithms/sum/maxsubsum"
 	"ads/internal/core/logging"
-	"ads/internal/setup"
-	"ads/internal/types"
 )
 
 /* ---------------------------------------------------------------- *

code/golang/internal/menus/menus.go

@@ -15,14 +15,6 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-/* ---------------------------------------------------------------- *
- * METHOD menu class methods
- * ---------------------------------------------------------------- */
-
-func (menu *Menu) SetDefault(index int) {
-	menu.Default = index
-}
-
 /* ---------------------------------------------------------------- *
  * METHOD show menu
  * ---------------------------------------------------------------- */
@@ -37,8 +29,7 @@ func (menu Menu) ShowMenu() (bool, error) {
 		err    error
 	)
 	var promptMessages []string
-	var optionsFlattened []MenuOption
-	var optionsKeyValue [][2]string
+	var options [][2]string
 	var defaultOption string
 	var breaks []int
 
@@ -49,32 +40,22 @@ func (menu Menu) ShowMenu() (bool, error) {
 	promptMessages = append([]string{head}, promptMessages...)
 
 	// Zurück-Option einfügen
-	defaultOption = ""
-	if menu.Default >= 0 {
-		defaultOption = fmt.Sprintf("%v", menu.Default+1)
-	}
-	breaks = []int{}
-	optionsFlattened = []MenuOption{}
-	optionsKeyValue = []([2]string){}
-	index = 0
-	for _, suboptions := range menu.Options {
-		for _, opt := range suboptions {
-			optionsFlattened = append(optionsFlattened, opt)
-			key := fmt.Sprintf("%v", index+1)
+	defaultOption = fmt.Sprintf("%v", menu.DefaultOption)
+	options = []([2]string){}
+	for i, opt := range menu.Options {
+		key := fmt.Sprintf("%v", i+1)
 		subLabel := opt.SubLabel
 		label := opt.Label
 		if !(subLabel == "") {
 			label = fmt.Sprintf("%v (\033[2m%v\033[0m)", opt.Label, subLabel)
 		}
-			optionsKeyValue = append(optionsKeyValue, [2]string{key, label})
-			index++
-		}
-		breaks = append(breaks, index-1)
+		options = append(options, [2]string{key, label})
 	}
+	breaks = []int{len(menu.Options) - 1}
 	if !menu.IsRoot {
-		optionsKeyValue = append(optionsKeyValue, [2]string{"z", "Zurück zum vorherigen Menü"})
+		options = append(options, [2]string{"z", "Zurück zum vorherigen Menü"})
 	}
-	optionsKeyValue = append(optionsKeyValue, [2]string{"q", "Programm schließen"})
+	options = append(options, [2]string{"q", "Programm schließen"})
 
 	// User Response immer abfragen und abarbeiten, bis quit/return.
 	performClearScreen := !menu.IsRoot
@@ -84,7 +65,7 @@ func (menu Menu) ShowMenu() (bool, error) {
 		}
 		performClearScreen = true
 
-		choice, meta = promptListOfOptions(promptMessages, optionsKeyValue, breaks, defaultOption)
+		choice, meta = PromptListOfOptions(promptMessages, options, breaks, defaultOption)
 
 		// Falls quit wählt, -> quit:
 		if (menu.IsRoot && meta) || choice == "q" {
@@ -99,8 +80,8 @@ func (menu Menu) ShowMenu() (bool, error) {
 		// sonst führe die assoziierte Methode aus
 		index64, _ := strconv.ParseInt(choice, 10, 64)
 		index = int(index64) - 1
-		if 0 <= index && index < len(optionsFlattened) {
-			opt := optionsFlattened[index]
+		if 0 <= index && index < len(menu.Options) {
+			opt := menu.Options[index]
 			// Entweder Untermenü öffnen oder Action ausführen
 			if opt.Submenu != nil {
 				quit, err = opt.Submenu.ShowMenu()
@@ -112,20 +93,14 @@ func (menu Menu) ShowMenu() (bool, error) {
 				if err != nil {
 					logging.LogError(err)
 				}
-				// Falls ForceReturn, dann nach Ausführung der Action, -> return
-				if menu.ForceReturn {
-					return false, nil
-				} else {
-					// Falls während der Action der User Meta+D klickt, -> return:
 				if cancel {
 					continue
 				}
 				quit := logging.PromptAnyKeyToContinue()
-					// Falls nach der Action der User Meta+D klickt, -> quit:
+				// Falls während der Action der User Meta+D klickt, -> quit:
 				if quit {
 					return true, nil
 				}
-				}
 			} else {
 				logging.LogWarn("Option noch nicht implementiert.")
 				quit := logging.PromptAnyKeyToContinue()

code/golang/internal/menus/menus_prompt.go

@@ -6,7 +6,6 @@ package menus
 
 import (
 	"fmt"
-	"strings"
 
 	"ads/internal/core/logging"
 	"ads/internal/core/utils"
@@ -17,7 +16,7 @@ import (
  * ---------------------------------------------------------------- */
 
 // Zeigt Prompt mit Liste von Optionen an
-func promptListOfOptions(messages []string, options [][2]string, breaks []int, defaultChoice string) (string, bool) {
+func PromptListOfOptions(messages []string, options [][2]string, breaks []int, defaultChoice string) (string, bool) {
 	var n = len(options)
 	var (
 		choice string
@@ -33,8 +32,6 @@ func promptListOfOptions(messages []string, options [][2]string, breaks []int, d
 		lines = append(lines, message)
 	}
 	lines = append(lines, "")
-	textbar := fmt.Sprintf(" \033[93m+%s+\033[0m", strings.Repeat("-", 40))
-	lines = append(lines, textbar)
 	for i, obj := range options {
 		key := obj[0]
 		label := obj[1]
@@ -45,12 +42,11 @@ func promptListOfOptions(messages []string, options [][2]string, breaks []int, d
 			lines = append(lines, fmt.Sprintf(" \033[93;1m%v)\033[0m %v", key, label))
 		}
 		if i < n-1 && utils.ArrayContains(breaks, i) {
-			lines = append(lines, " \033[93m+----\033[0m")
+			lines = append(lines, " \033[93m--------\033[0m")
 		}
 		i++
 	}
-	lines = append(lines, textbar)
-	if !(defaultChoice == "") {
+	if !(defaultChoice == "" || defaultChoice == "-1") {
 		lines = append(lines, "")
 		lines = append(lines, "\033[91;2m*\033[0m\033[2m = Default\033[0m")
 	}

code/golang/internal/menus/menus_type.go

@@ -19,11 +19,10 @@ type MenuOption struct {
 
 type Menu struct {
 	IsRoot         bool
-	ForceReturn    bool
 	Path           []string
 	PromptMessages []string
-	Options        [][]MenuOption
-	Default        int
+	Options        []MenuOption
+	DefaultOption  int
 }
 
 /* ---------------------------------------------------------------- *

code/golang/internal/setup/cli/cli.go

@@ -5,12 +5,9 @@ package cli
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"github.com/akamensky/argparse"
 
 	"ads/internal/types"
-	"ads/pkg/re"
 )
 
 /* ---------------------------------------------------------------- *
@@ -65,7 +62,6 @@ var optionsConfigFile = argparse.Options{
  * METHODS parse cli
  * ---------------------------------------------------------------- */
 
-// Parst cli flags.
 func ParseCli(args []string) (*types.CliArguments, error) {
 	var err error
 	Parser = argparse.NewParser("cli parser", "Liest Optionen + Flags von Kommandozeile.")
@@ -83,9 +79,3 @@ func ParseCli(args []string) (*types.CliArguments, error) {
 	err = Parser.Parse(args)
 	return &arguments, err
 }
-
-// Prüft, ob der Parser nur deshalb fehlschlägt, weil ein Command fehlt.
-func ParseCliCommandMissing(err error) bool {
-	// FIXME: unschöne Lösung. Leider ist Error-Typ im Package versteckt
-	return re.Matches(`(?i)(command required)`, fmt.Sprintf("%v", err))
-}

code/golang/internal/setup/setup_appconfig.go

@@ -5,9 +5,9 @@ package setup
  * ---------------------------------------------------------------- */
 
 import (
-	"gopkg.in/yaml.v3"
-
 	"ads/internal/types"
+
+	"gopkg.in/yaml.v3"
 )
 
 /* ---------------------------------------------------------------- *

code/golang/internal/setup/setup_userconfig.go

@@ -5,11 +5,10 @@ package setup
  * ---------------------------------------------------------------- */
 
 import (
+	"ads/internal/types"
 	"io/ioutil"
 
 	"gopkg.in/yaml.v3"
-
-	"ads/internal/types"
 )
 
 /* ---------------------------------------------------------------- *

code/golang/main.go

@@ -45,15 +45,10 @@ func main() {
 
 	// cli arguments parsen
 	arguments, err = cli.ParseCli(os.Args)
-	cmdMissing := cli.ParseCliCommandMissing(err)
 
 	// initialisiere basic optionen wie Logging
 	if err == nil {
-		quiet := arguments.QuietModeOn()
-		if arguments.InteractiveMode() {
-			quiet = false
-		}
-		logging.SetQuietMode(quiet)
+		logging.SetQuietMode(arguments.QuietModeOn())
 		logging.SetDebugMode(arguments.DebugModeOn())
 		logging.SetAnsiMode(arguments.ShowColour())
 	}
@@ -76,13 +71,9 @@ func main() {
 			} else {
 				err = endpoints.RunNonInteractive(arguments.GetConfigFile())
 			}
-		} else if arguments.ModeHelp.Happened() {
+		} else { // } else if arguments.Help.Happened() {
 			endpoints.Help()
-		} else {
-			err = endpoints.RunInteractive()
 		}
-	} else if cmdMissing {
-		err = endpoints.RunInteractive()
 	}
 
 	if err != nil {