From 46d032cd21b0e8e2c94a32333d3805ec76980cca Mon Sep 17 00:00:00 2001
From: ewy <ewy0@protonmail.com>
Date: Mon, 1 Jun 2026 18:47:44 +0200
Subject: add man(1) generation

---
 modes.go | 58 ++++++++++++++++++++++++++++------------------------------
 1 file changed, 28 insertions(+), 30 deletions(-)

(limited to 'modes.go')

diff --git a/modes.go b/modes.go
index ec599a6..b8da9b0 100644
--- a/modes.go
+++ b/modes.go
@@ -1,10 +1,10 @@
 package main
 
 import (
+	_ "embed"
 	"errors"
 	"github.com/ewy1/pik/completion"
 	"github.com/ewy1/pik/flags"
-	"github.com/ewy1/pik/help"
 	"github.com/ewy1/pik/model"
 	"github.com/ewy1/pik/paths"
 	"github.com/ewy1/pik/run"
@@ -22,77 +22,75 @@ type ModeMap[T any] map[*bool]T
 var Continue = errors.New("not an error; continue flow")
 var Success = errors.New("not an error; finished operations")
 
+//go:embed man/help.txt
+var help string
+
+//go:embed man/version.txt
+var version string
+
 // Traverse checks the entries of the map. If any flags are set on,
 // pik that mode. If Continue is returned, it's non-exclusive. Otherwise,
 // we quit after one mode.
 //
 // `then` should simply be the method call (necessary due to generics)
-func (m ModeMap[T]) Traverse(then func(in T) error) error {
+func (m ModeMap[T]) Traverse(then func(in T) *spool.ExitCode) *spool.ExitCode {
 	for enabled, mode := range m {
 		if !*enabled {
 			continue
 		}
-		err := then(mode)
-		if errors.Is(err, Continue) {
-			continue
-		} else if err != nil {
-			return err
-		}
-		return Success
+		return then(mode)
 	}
 	return nil
 }
 
 var profileFd *os.File
 
-var UnknownShellError = errors.New("$SHELL not set or empty")
-
 // uninitializedModes are modes which can run before the program runs initializers
-var uninitializedModes = ModeMap[func() error]{
-	flags.Version: func() error {
-		_, err := spool.Print("%s\n", version)
-		return err
+var uninitializedModes = ModeMap[func() *spool.ExitCode]{
+	flags.Version: func() *spool.ExitCode {
+		_, _ = spool.Print("%s\n", version)
+		return &spool.Success
 	},
-	flags.Completion: func() error {
+	flags.Completion: func() *spool.ExitCode {
 		return completion.Echo()
 	},
-	flags.Help: func() error {
-		help.Echo()
+	flags.Help: func() *spool.ExitCode {
+		_, _ = spool.Print("%s\n", help)
 		return nil
 	},
 }
 
 // statelessModes are program modes which do not require state to operate.
 // like --version and --completion
-var statelessModes = ModeMap[func() error]{
-	flags.InstallCompletion: func() error {
+var statelessModes = ModeMap[func() *spool.ExitCode]{
+	flags.InstallCompletion: func() *spool.ExitCode {
 		sh := os.Getenv("SHELL")
 		if sh == "" {
-			return UnknownShellError
+			return &spool.UnknownShellFailure
 		}
 		_, sh = filepath.Split(sh)
 		return completion.Add(sh)
 	},
-	flags.Profile: func() error {
+	flags.Profile: func() *spool.ExitCode {
 		fd, err := os.Create("pik-profile.out")
 		if err != nil {
-			return err
+			return &spool.FatalWriteFailure
 		}
 		runtime.SetCPUProfileRate(1000)
 		err = pprof.StartCPUProfile(profileFd)
 		if err != nil {
-			return err
+			return &spool.ProfilingFailure
 		}
 		profileFd = fd
-		return Continue
+		return nil
 	},
 }
 
 var NoTargetsError = errors.New("no targets or sources to list")
 
 // statefulModes are program modes which require a built state to be executed
-var statefulModes = ModeMap[func(st *model.State) error]{
-	flags.List: func(st *model.State) error {
+var statefulModes = ModeMap[func(st *model.State) *spool.ExitCode]{
+	flags.List: func(st *model.State) *spool.ExitCode {
 		count := 0
 		for _, s := range st.Sources {
 			count++
@@ -104,15 +102,15 @@ var statefulModes = ModeMap[func(st *model.State) error]{
 		}
 
 		if count == 0 {
-			return NoTargetsError
+			return &spool.NoTargetsFailure
 		}
 		return nil
 	},
 }
 
 // selectionModes are program modes which require a selected target, through menu or args
-var selectionModes = ModeMap[func(st *model.State, src *model.Source, t model.Target) error]{
-	flags.Edit: func(st *model.State, src *model.Source, t model.Target) error {
+var selectionModes = ModeMap[func(st *model.State, src *model.Source, t model.Target) *spool.ExitCode]{
+	flags.Edit: func(st *model.State, src *model.Source, t model.Target) *spool.ExitCode {
 		return run.Edit(t, src)
 	},
 }
-- 
cgit v1.3.1