Provide a way of iterating over all flags

Author: FollowTheProcess

internal/flag/set.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"iter"
 	"slices"
 	"strings"
 
@@ -187,6 +188,25 @@ func (s *Set) Parse(args []string) (err error) {
 	return nil
 }
 
+// All returns an iterator through the flags in the flagset
+// in alphabetical order by name.
+func (s *Set) All() iter.Seq2[string, Value] {
+	return func(yield func(string, Value) bool) {
+		names := make([]string, 0, len(s.flags))
+		for name := range s.flags {
+			names = append(names, name)
+		}
+
+		slices.Sort(names)
+
+		for _, name := range names {
+			if !yield(name, s.flags[name]) {
+				return
+			}
+		}
+	}
+}
+
 // Usage returns a string containing the usage info of all flags in the set.
 func (s *Set) Usage() (string, error) {
 	buf := &bytes.Buffer{}

internal/flag/set_test.go

@@ -3,8 +3,11 @@ package flag_test
 import (
 	goflag "flag"
 	"fmt"
+	"iter"
+	"maps"
 	"slices"
 	"testing"
+	"time"
 
 	publicflag "go.followtheprocess.codes/cli/flag"
 	"go.followtheprocess.codes/cli/internal/flag"
@@ -1209,6 +1212,99 @@ func TestHelpVersion(t *testing.T) {
 	}
 }
 
+func TestAll(t *testing.T) {
+	tests := []struct {
+		newSet func(t *testing.T) *flag.Set
+		test   func(t *testing.T, set *flag.Set)
+		name   string
+	}{
+		{
+			name: "empty",
+			newSet: func(t *testing.T) *flag.Set {
+				return flag.NewSet()
+			},
+			test: func(t *testing.T, set *flag.Set) {
+				// Iterator should yield no values
+				got := maps.Collect(set.All())
+				test.Equal(t, len(got), 0)
+			},
+		},
+		{
+			name: "full",
+			newSet: func(t *testing.T) *flag.Set {
+				set := flag.NewSet()
+
+				verbose, err := flag.New(new(bool), "verbose", 'v', "Show verbose info", flag.Config[bool]{})
+				test.Ok(t, err)
+
+				debug, err := flag.New(new(bool), "debug", 'd', "Show debug info", flag.Config[bool]{})
+				test.Ok(t, err)
+
+				thing, err := flag.New(new(string), "thing", 't', "A thing", flag.Config[string]{})
+				test.Ok(t, err)
+
+				number, err := flag.New(new(int), "number", 'n', "Number of times", flag.Config[int]{})
+				test.Ok(t, err)
+
+				duration, err := flag.New(new(time.Duration), "duration", 'D', "The time to do something for", flag.Config[time.Duration]{})
+				test.Ok(t, err)
+
+				test.Ok(t, flag.AddToSet(set, verbose))
+				test.Ok(t, flag.AddToSet(set, debug))
+				test.Ok(t, flag.AddToSet(set, thing))
+				test.Ok(t, flag.AddToSet(set, number))
+				test.Ok(t, flag.AddToSet(set, duration))
+
+				return set
+			},
+			test: func(t *testing.T, set *flag.Set) {
+				// Iterator should yield no values
+				next, stop := iter.Pull2(set.All())
+				defer stop()
+
+				// Should now be in alphabetical order
+				name, fl, ok := next()
+				test.True(t, ok)
+				test.Equal(t, name, "debug")
+				test.Equal(t, fl.Name(), "debug")
+
+				name, fl, ok = next()
+				test.True(t, ok)
+				test.Equal(t, name, "duration")
+				test.Equal(t, fl.Name(), "duration")
+
+				name, fl, ok = next()
+				test.True(t, ok)
+				test.Equal(t, name, "number")
+				test.Equal(t, fl.Name(), "number")
+
+				name, fl, ok = next()
+				test.True(t, ok)
+				test.Equal(t, name, "thing")
+				test.Equal(t, fl.Name(), "thing")
+
+				name, fl, ok = next()
+				test.True(t, ok)
+				test.Equal(t, name, "verbose")
+				test.Equal(t, fl.Name(), "verbose")
+
+				// Thats it
+				name, fl, ok = next()
+				test.False(t, ok)
+				test.Equal(t, name, "")
+				test.Equal(t, fl, nil)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			set := tt.newSet(t)
+			tt.test(t, set)
+		})
+	}
+}
+
 func TestUsage(t *testing.T) {
 	tests := []struct {
 		newSet func(t *testing.T) *flag.Set // Function to build the flag set under test