Create choice package (#16)

Author: sunshineplan

choice/choice.go

@@ -0,0 +1,59 @@
+package choice
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func choiceStr(choice any) string {
+	if v, ok := choice.(Description); ok {
+		return v.Description()
+	} else if v, ok := choice.(fmt.Stringer); ok {
+		return v.String()
+	}
+	return fmt.Sprint(choice)
+}
+
+func Menu[E Choice](choices []E) string {
+	var digit int
+	for n := len(choices); n != 0; digit++ {
+		n /= 10
+	}
+	option := fmt.Sprintf("%%%dd", digit)
+	var b strings.Builder
+	for i, choice := range choices {
+		fmt.Fprintf(&b, "%s. %s\n", fmt.Sprintf(option, i+1), choiceStr(choice))
+	}
+	return b.String()
+}
+
+func choose[E Choice](choice string, choices []E) (res any, err error) {
+	n, err := strconv.Atoi(choice)
+	if err != nil {
+		return nil, choiceError(choice)
+	}
+	if length := len(choices); n < 1 || n > length {
+		return nil, choiceError(fmt.Sprintf("out of range(1-%d): %d", length, n))
+	}
+	return choices[n-1].Run()
+}
+
+func Choose[E Choice](choices []E) (choice string, res any, err error) {
+	if length := len(choices); length == 0 {
+		return
+	}
+	fmt.Print(Menu(choices))
+	fmt.Print("\nPlease choose: ")
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	b := bytes.TrimSpace(scanner.Bytes())
+	if bytes.EqualFold(b, []byte("q")) || bytes.Contains(b, []byte{27}) {
+		return
+	}
+	res, err = choose(string(b), choices)
+	return
+}

choice/choice_test.go

@@ -0,0 +1,50 @@
+package choice
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var (
+	_ Choice      = a("")
+	_ Description = a("")
+)
+
+type a string
+
+func (s a) Run() (any, error) {
+	return s, nil
+}
+
+func (s a) Description() string {
+	return strings.Repeat(string(s), 2)
+}
+
+func (s a) String() string {
+	return string(s)
+}
+
+func TestMenu(t *testing.T) {
+	choices := []a{"a", "b", "c"}
+	expect := `1. aa
+2. bb
+3. cc
+`
+	if s := Menu(choices); s != expect {
+		t.Errorf("expected %q; got %q", expect, s)
+	}
+}
+
+func TestChoose(t *testing.T) {
+	choices := []a{"a", "b", "c"}
+	if _, err := choose("4", choices); !errors.Is(err, ErrBadChoice) {
+		t.Errorf("expected ErrBadChoice; got %s", err)
+	}
+	if s, err := choose("2", choices); err != nil {
+		t.Fatal(err)
+	} else if expect := "b"; fmt.Sprint(s) != expect {
+		t.Errorf("expected %q; got %q", expect, s)
+	}
+}

choice/types.go

@@ -0,0 +1,25 @@
+package choice
+
+import "errors"
+
+type Choice interface {
+	Run() (any, error)
+}
+
+type Description interface {
+	Description() string
+}
+
+var ErrBadChoice = errors.New("bad choice")
+
+var _ error = choiceError("")
+
+type choiceError string
+
+func (err choiceError) Error() string {
+	return "bad choice: " + string(err)
+}
+
+func (choiceError) Unwrap() error {
+	return ErrBadChoice
+}

choice/types_test.go

@@ -0,0 +1,12 @@
+package choice
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestError(t *testing.T) {
+	if !errors.Is(choiceError(""), ErrBadChoice) {
+		t.Error("expected err is ErrBadChoice; got not")
+	}
+}