package stario import ( "bufio" "fmt" "os" "strconv" "strings" "golang.org/x/crypto/ssh/terminal" ) type InputMsg struct { msg string err error skipSliceSigErr bool } func Passwd(hint string, defaultVal string) InputMsg { return passwd(hint, defaultVal, "") } func PasswdWithMask(hint string, defaultVal string, mask string) InputMsg { return passwd(hint, defaultVal, mask) } func MessageBoxRaw(hint string, defaultVal string) InputMsg { return messageBox(hint, defaultVal) } func messageBox(hint string, defaultVal string) InputMsg { var ioBuf []rune if hint != "" { fmt.Print(hint) } if strings.Index(hint, "\n") >= 0 { hint = strings.TrimSpace(hint[strings.LastIndex(hint, "\n"):]) } fd := int(os.Stdin.Fd()) state, err := terminal.MakeRaw(fd) if err != nil { return InputMsg{msg: "", err: err} } defer fmt.Println() defer terminal.Restore(fd, state) inputReader := bufio.NewReader(os.Stdin) for { b, _, err := inputReader.ReadRune() if err != nil { return InputMsg{msg: "", err: err} } if b == 0x0d { strValue := strings.TrimSpace(string(ioBuf)) if len(strValue) == 0 { strValue = defaultVal } return InputMsg{msg: strValue, err: err} } if b == 0x08 || b == 0x7F { if len(ioBuf) > 0 { ioBuf = ioBuf[:len(ioBuf)-1] } fmt.Print("\r") for i := 0; i < len(ioBuf)+2+len(hint); i++ { fmt.Print(" ") } } else { ioBuf = append(ioBuf, b) } fmt.Print("\r") if hint != "" { fmt.Print(hint) } fmt.Print(string(ioBuf)) } } func passwd(hint string, defaultVal string, mask string) InputMsg { var ioBuf []rune if hint != "" { fmt.Print(hint) } if strings.Index(hint, "\n") >= 0 { hint = strings.TrimSpace(hint[strings.LastIndex(hint, "\n"):]) } fd := int(os.Stdin.Fd()) state, err := terminal.MakeRaw(fd) if err != nil { return InputMsg{msg: "", err: err} } defer fmt.Println() defer terminal.Restore(fd, state) inputReader := bufio.NewReader(os.Stdin) for { b, _, err := inputReader.ReadRune() if err != nil { return InputMsg{msg: "", err: err} } if b == 0x0d { strValue := strings.TrimSpace(string(ioBuf)) if len(strValue) == 0 { strValue = defaultVal } return InputMsg{msg: strValue, err: err} } if b == 0x08 || b == 0x7F { if len(ioBuf) > 0 { ioBuf = ioBuf[:len(ioBuf)-1] } fmt.Print("\r") for i := 0; i < len(ioBuf)+2+len(hint); i++ { fmt.Print(" ") } } else { ioBuf = append(ioBuf, b) } fmt.Print("\r") if hint != "" { fmt.Print(hint) } for i := 0; i < len(ioBuf); i++ { fmt.Print(mask) } } } func MessageBox(hint string, defaultVal string) InputMsg { if hint != "" { fmt.Print(hint) } inputReader := bufio.NewReader(os.Stdin) str, err := inputReader.ReadString('\n') if err != nil { return InputMsg{msg: str, err: err} } str = strings.TrimSpace(str) if len(str) == 0 { str = defaultVal } return InputMsg{msg: str, err: err} } func (im InputMsg) IgnoreSliceParseError(i bool) InputMsg { im.skipSliceSigErr = i return im } func (im InputMsg) String() (string, error) { if im.err != nil { return "", im.err } return im.msg, nil } func (im InputMsg) MustString() string { res, _ := im.String() return res } func (im InputMsg) SliceString(sep string) ([]string, error) { if im.err != nil { return nil, im.err } return strings.Split(im.msg, sep), nil } func (im InputMsg) MustSliceString(sep string) []string { res, _ := im.SliceString(sep) return res } func (im InputMsg) sliceFn(sep string, fn func(string) (interface{}, error)) ([]interface{}, error) { var res []interface{} data, err := im.SliceString(sep) if err != nil { return res, err } for _, v := range data { code, err := fn(v) if err != nil && !im.skipSliceSigErr { return nil, err } else if err == nil { res = append(res, code) } } return res, nil } func (im InputMsg) Int() (int, error) { if im.err != nil { return 0, im.err } return strconv.Atoi(im.msg) } func (im InputMsg) SliceInt(sep string) ([]int, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.Atoi(v) }) var res []int for _, v := range data { res = append(res, v.(int)) } return res, err } func (im InputMsg) MustSliceInt(sep string) []int { res, _ := im.SliceInt(sep) return res } func (im InputMsg) MustInt() int { res, _ := im.Int() return res } func (im InputMsg) Int64() (int64, error) { if im.err != nil { return 0, im.err } return strconv.ParseInt(im.msg, 10, 64) } func (im InputMsg) MustInt64() int64 { res, _ := im.Int64() return res } func (im InputMsg) SliceInt64(sep string) ([]int64, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.ParseInt(v, 10, 64) }) var res []int64 for _, v := range data { res = append(res, v.(int64)) } return res, err } func (im InputMsg) MustSliceInt64(sep string) []int64 { res, _ := im.SliceInt64(sep) return res } func (im InputMsg) Uint64() (uint64, error) { if im.err != nil { return 0, im.err } return strconv.ParseUint(im.msg, 10, 64) } func (im InputMsg) MustUint64() uint64 { res, _ := im.Uint64() return res } func (im InputMsg) SliceUint64(sep string) ([]uint64, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.ParseUint(v, 10, 64) }) var res []uint64 for _, v := range data { res = append(res, v.(uint64)) } return res, err } func (im InputMsg) MustSliceUint64(sep string) []uint64 { res, _ := im.SliceUint64(sep) return res } func (im InputMsg) Bool() (bool, error) { if im.err != nil { return false, im.err } return strconv.ParseBool(im.msg) } func (im InputMsg) MustBool() bool { res, _ := im.Bool() return res } func (im InputMsg) SliceBool(sep string) ([]bool, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.ParseBool(v) }) var res []bool for _, v := range data { res = append(res, v.(bool)) } return res, err } func (im InputMsg) MustSliceBool(sep string) []bool { res, _ := im.SliceBool(sep) return res } func (im InputMsg) Float64() (float64, error) { if im.err != nil { return 0, im.err } return strconv.ParseFloat(im.msg, 64) } func (im InputMsg) MustFloat64() float64 { res, _ := im.Float64() return res } func (im InputMsg) SliceFloat64(sep string) ([]float64, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.ParseFloat(v, 64) }) var res []float64 for _, v := range data { res = append(res, v.(float64)) } return res, err } func (im InputMsg) MustSliceFloat64(sep string) []float64 { res, _ := im.SliceFloat64(sep) return res } func (im InputMsg) Float32() (float32, error) { if im.err != nil { return 0, im.err } res, err := strconv.ParseFloat(im.msg, 32) return float32(res), err } func (im InputMsg) MustFloat32() float32 { res, _ := im.Float32() return res } func (im InputMsg) SliceFloat32(sep string) ([]float32, error) { data, err := im.sliceFn(sep, func(v string) (interface{}, error) { return strconv.ParseFloat(v, 32) }) var res []float32 for _, v := range data { res = append(res, v.(float32)) } return res, err } func (im InputMsg) MustSliceFloat32(sep string) []float32 { res, _ := im.SliceFloat32(sep) return res } func YesNo(hint string, defaults bool) bool { for { res := strings.ToUpper(MessageBox(hint, "").MustString()) if res == "" { return defaults } res = res[0:1] if res == "Y" { return true } else if res == "N" { return false } } } func StopUntil(hint string, trigger string, repeat bool) error { pressLen := len([]rune(trigger)) if trigger == "" { pressLen = 1 } fd := int(os.Stdin.Fd()) if hint != "" { fmt.Print(hint) } state, err := terminal.MakeRaw(fd) if err != nil { return err } defer terminal.Restore(fd, state) inputReader := bufio.NewReader(os.Stdin) //ioBuf := make([]byte, pressLen) i := 0 for { b, _, err := inputReader.ReadRune() if err != nil { return err } if trigger == "" { break } if b == []rune(trigger)[i] { i++ if i == pressLen { break } continue } i = 0 if hint != "" && repeat { fmt.Print("\r\n") fmt.Print(hint) } } return nil }