README
¶
Command-shell
A go library for creating simple command-based tui's (terminal user interfaces).
Built on top of this keyboard package.
Features
- Default
exitcommand - Minimal number of arguments safety
- Commands can store data
- Up-arrow for previous command
- History
- Default & automatic
helpcommand - Customizable
LinePrefix - And more...
TODO
- Tab autocomplete
- Cursor moving around line
Example
output
> add 2 6
8
>
code
package main
// imports
import (
"fmt"
"strconv"
shell "github.com/48thFlame/Command-Shell"
)
// addCommand represents the `add` command you can see in the output section
func addCommand(input *shell.CommandInput) error {
args := input.Args
// convert arguments to numbers
// can safely assume there will be at lease 2 arguments
// we specify this in the `shell.NewCommand` constructor
a, err := strconv.Atoi(args[0])
if err != nil {
return err
}
b, err := strconv.Atoi(args[1])
if err != nil {
return err
}
// output the addition
fmt.Fprint(input.Stdout, a+b)
// no errors occurred
return nil
}
func timesRanCommand(input *shell.CommandInput) error {
// get number of times ran
// if doesn't exist the error will be thrown away `_` and val will be the default int -> 0
val, _ := input.Cmd.Data["times"].(int)
// increment `times` by 1
input.Cmd.Data["times"] = val + 1
// output times ran
fmt.Fprint(input.Stdout, val)
// no errors
return nil
}
func main() {
s, err := shell.NewShell(
shell.NewCommand("add", 2, addCommand),
shell.NewCommand("times", 0, timesRanCommand),
)
if err != nil {
panic(err)
}
err = s.Run()
if err != nil {
panic(err)
}
}
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Command ¶
type Command struct {
Name string // commands name
MinNumOfArgs int // minium number of arguments needed to run command
Handler HandlerType // the `HandlerType` for this command
Data map[string]interface{} // data stored for the command
}
Command type, use
NewCommand()
to create a new Command
func NewCommand ¶
func NewCommand(name string, minNumOfArgs int, handler HandlerType) *Command
NewCommand returns a `Command` type, Args:
name // name used to call command minNumOfArgs // minimum number of arguments needed for command to run (the `Shell` won't call the command without enough args) handler // the handler to call for the command
type CommandInput ¶
type CommandInput struct {
Shell *Shell // the `Shell` type
Stdout io.Writer // write any command output to here, avoid printing to `os.Stdout`
Args []string // command-line arguments
Cmd *Command // the `Command` type
}
CommandInput is the input type for `CommandHandler` function
type HandlerType ¶
type HandlerType func(*CommandInput) error
HandlerType is the type for
Command.Handler
Its a function called when running its command
type Shell ¶
type Shell struct {
LinePrefix string // Prefix printed at beginning of every command line
Path map[string]*Command // Similar to unix $PATH
// contains filtered or unexported fields
}
Shell type the main part of the program, use
NewShell()
to create a new Shell
func NewShell ¶
Return a new `Shell` and any `error` that occurred. Takes as input a `[]Command` that the shell should know how to run, Use the `NewCommand` function to create new `Command`s NewShell is the constructor for `Shell` type
func (*Shell) GetHistory ¶
GetHistory returns command history similar to Unix history, user can use default `history` command to display history
Source Files