cli-ui,web: real flag parsing for lectio-ui/lectio-web (accept useful flags, reject unknown, -h/-v)

2 files changed, 260 insertions, 5 deletions

diff --git a/cmd/lectio-ui/main.go b/cmd/lectio-ui/main.go
index 13e3551..1808e4a 100644
--- a/cmd/lectio-ui/main.go
+++ b/cmd/lectio-ui/main.go
@@ -1,8 +1,12 @@
+// Command lectio-ui is lectio's interactive Bubble Tea reader.
 package main
 
 import (
+	"flag"
 	"fmt"
+	"io"
 	"os"
+	"regexp"
 
 	tea "github.com/charmbracelet/bubbletea"
 
@@ -10,14 +14,162 @@ import (
 	"github.com/lukaszkasprzak/lectio/internal/tui"
 )
 
+const helpText = `lectio-ui — interactive daily liturgy reader (Polish + 4 versions)
+
+Usage:
+  lectio-ui [DATE] [flags]     DATE = YYYY-MM-DD (default: today), any position
+
+Flags:
+  -b, --bible VER        start on version: pl,wuj,vul,grb,drb
+  -a, --all               show all parts (override config)
+  -o, --offline            cache/sigla only, no network
+  -l, --lectionary WHICH   new|trad (trad -> traditional)
+  -g, --lang LANG          traditional lectionary language: pl|en
+  -v, --version            print the version and exit
+  -h, --help               this help
+
+Versions: pl (Polski/niedziela.pl) wuj (Wujek) vul (Wulgata) grb (Grecki)
+          drb (Douay-Rheims)
+
+Flags override config. Exit codes: 0 ok, 1 runtime error, 2 usage error.
+`
+
+var dateRe = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
+
 func main() {
+	os.Exit(run(os.Args[1:], os.Stdout, os.Stderr))
+}
+
+// run is lectio-ui's testable entry point: parse args, validate, load
+// config, apply overrides, and launch the TUI. Returns a process exit code.
+func run(args []string, stdout, stderr io.Writer) int {
+	if wantsHelp(args) {
+		fmt.Fprint(stdout, helpText)
+		return 0
+	}
+	if wantsVersion(args) {
+		fmt.Fprintln(stdout, "lectio-ui "+config.Version)
+		return 0
+	}
+
+	date, rest, err := extractDate(args)
+	if err != nil {
+		fmt.Fprintln(stderr, "lectio-ui:", err)
+		return 2
+	}
+
 	cfg, err := config.Load()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
+		fmt.Fprintln(stderr, "lectio-ui:", err)
+		return 1
+	}
+
+	var all, offline bool
+	var bibleVer, lectionary, lang string
+
+	fs := flag.NewFlagSet("lectio-ui", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	fs.Usage = func() { fmt.Fprint(stderr, helpText) }
+
+	fs.StringVar(&bibleVer, "b", "", "start on version: pl,wuj,vul,grb,drb")
+	fs.StringVar(&bibleVer, "bible", "", "start on version: pl,wuj,vul,grb,drb")
+	fs.BoolVar(&all, "a", cfg.All, "show all parts (override config)")
+	fs.BoolVar(&all, "all", cfg.All, "show all parts (override config)")
+	fs.BoolVar(&offline, "o", cfg.Offline, "cache/sigla only, no network")
+	fs.BoolVar(&offline, "offline", cfg.Offline, "cache/sigla only, no network")
+	fs.StringVar(&lectionary, "l", "", "new|trad")
+	fs.StringVar(&lectionary, "lectionary", "", "new|trad")
+	fs.StringVar(&lang, "g", "", "pl|en")
+	fs.StringVar(&lang, "lang", "", "pl|en")
+
+	if err := fs.Parse(rest); err != nil {
+		return 2
+	}
+	if fs.NArg() > 0 {
+		fmt.Fprintf(stderr, "lectio-ui: unexpected argument %q; see 'lectio-ui -h'\n", fs.Arg(0))
+		return 2
+	}
+
+	lectionary, err = normalizeLectionary(lectionary)
+	if err != nil {
+		fmt.Fprintln(stderr, "lectio-ui:", err)
+		return 2
+	}
+	if lang != "" && lang != "pl" && lang != "en" {
+		fmt.Fprintf(stderr, "lectio-ui: invalid --lang %q (want pl|en)\n", lang)
+		return 2
+	}
+	if bibleVer != "" && !config.ValidVersion(bibleVer) {
+		fmt.Fprintf(stderr, "lectio-ui: unknown version %q (want one of pl, wuj, vul, grb, drb)\n", bibleVer)
+		return 2
+	}
+
+	cfg.All = all
+	cfg.Offline = offline
+	if lectionary != "" {
+		cfg.Lectionary = lectionary
+	}
+	if lang != "" {
+		cfg.TraditionalLang = lang
+	}
+
+	if _, err := tea.NewProgram(tui.New(cfg, date, bibleVer), tea.WithAltScreen()).Run(); err != nil {
+		fmt.Fprintln(stderr, err)
+		return 1
+	}
+	return 0
+}
+
+// wantsHelp reports whether -h/--help appears anywhere in args.
+func wantsHelp(args []string) bool {
+	for _, a := range args {
+		if a == "-h" || a == "--help" {
+			return true
+		}
+	}
+	return false
+}
+
+// wantsVersion reports whether -v/--version appears anywhere in args.
+func wantsVersion(args []string) bool {
+	for _, a := range args {
+		if a == "-v" || a == "--version" {
+			return true
+		}
+	}
+	return false
+}
+
+// extractDate pulls the single positional DATE token (YYYY-MM-DD, matching
+// dateRe) out of args, wherever it appears, and returns it along with the
+// remaining tokens for flag.FlagSet to parse. Defaults to "" (New's
+// today-fallback) when no date token is present; errors if more than one is
+// found.
+func extractDate(args []string) (date string, rest []string, err error) {
+	found := false
+	for _, a := range args {
+		if dateRe.MatchString(a) {
+			if found {
+				return "", nil, fmt.Errorf("multiple dates given (%q and %q)", date, a)
+			}
+			date = a
+			found = true
+			continue
+		}
+		rest = append(rest, a)
+	}
+	return date, rest, nil
+}
+
+// normalizeLectionary maps -l/--lectionary's accepted spellings via
+// config.NormalizeLectionary; "" (flag not given) passes through unchanged.
+func normalizeLectionary(lectionary string) (string, error) {
+	if lectionary == "" {
+		return "", nil
 	}
-	if _, err := tea.NewProgram(tui.New(cfg), tea.WithAltScreen()).Run(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
+	v, ok := config.NormalizeLectionary(lectionary)
+	if !ok {
+		return "", fmt.Errorf("invalid --lectionary %q (want new|trad)", lectionary)
 	}
+	return v, nil
 }
diff --git a/cmd/lectio-ui/main_test.go b/cmd/lectio-ui/main_test.go
new file mode 100644
index 0000000..284fc67
--- /dev/null
+++ b/cmd/lectio-ui/main_test.go
@@ -0,0 +1,103 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestHelpFlag(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := run([]string{"-h"}, &out, &errb); code != 0 {
+		t.Errorf("-h code=%d (stderr=%q)", code, errb.String())
+	}
+	if !strings.Contains(out.String(), "lectio-ui") {
+		t.Errorf("-h output missing lectio-ui: %q", out.String())
+	}
+}
+
+func TestHelpLongFlag(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := run([]string{"--help"}, &out, &errb); code != 0 {
+		t.Errorf("--help code=%d (stderr=%q)", code, errb.String())
+	}
+	if !strings.Contains(out.String(), "lectio-ui") {
+		t.Errorf("--help output missing lectio-ui: %q", out.String())
+	}
+}
+
+func TestVersionFlag(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := run([]string{"-v"}, &out, &errb); code != 0 {
+		t.Errorf("-v code=%d (stderr=%q)", code, errb.String())
+	}
+	if !strings.Contains(out.String(), "lectio-ui") {
+		t.Errorf("-v output missing lectio-ui: %q", out.String())
+	}
+}
+
+func TestVersionLongFlag(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := run([]string{"--version"}, &out, &errb); code != 0 {
+		t.Errorf("--version code=%d (stderr=%q)", code, errb.String())
+	}
+	if !strings.Contains(out.String(), "lectio-ui") {
+		t.Errorf("--version output missing lectio-ui: %q", out.String())
+	}
+}
+
+func TestUnknownFlag(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"-x"}, &out, &errb); code != 2 {
+		t.Errorf("-x code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestUnknownLongFlag(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"--bogus"}, &out, &errb); code != 2 {
+		t.Errorf("--bogus code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestUnexpectedPositional(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"bogus"}, &out, &errb); code != 2 {
+		t.Errorf("unexpected positional code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestTwoDatesIsAmbiguous(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"2026-07-22", "2026-07-23"}, &out, &errb); code != 2 {
+		t.Errorf("two dates code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestLectionaryBogus(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"-l", "bogus"}, &out, &errb); code != 2 {
+		t.Errorf("bogus lectionary code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestLangBogus(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"-g", "xx"}, &out, &errb); code != 2 {
+		t.Errorf("bogus lang code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}
+
+func TestBibleVersionBogus(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+	var out, errb bytes.Buffer
+	if code := run([]string{"-b", "zzz"}, &out, &errb); code != 2 {
+		t.Errorf("bogus bible version code=%d want 2 (stderr=%q)", code, errb.String())
+	}
+}