Reconstruct and merge ordered inputs without general sorting

occurrence_test.go

@@ -150,3 +150,65 @@ func TestOccurrenceRequiredAndAliasedConversion(t *testing.T) {
 		t.Fatalf("help: %#v", help)
 	}
 }
+
+func TestNestedCapturedOccurrencesMergeSelections(t *testing.T) {
+	calls := 0
+	a := occurrenceFor("alpha", false, &calls)
+	b := RenameFlag(occurrenceFor("beta", false, &calls), "beta")
+	c := RenameFlag(occurrenceFor("gamma", false, &calls), "gamma")
+	type middle struct{ values FlagValues[occurrenceInput] }
+	type outer struct{ values FlagValues[middle] }
+	inner := CaptureFlags([]Flag[occurrenceInput]{a, b, c}, func(m *middle) *FlagValues[occurrenceInput] { return &m.values })
+	flags := CaptureFlags(inner, func(o *outer) *FlagValues[middle] { return &o.values })
+	var captured FlagValues[occurrenceInput]
+	app, err := New(Identity{Name: "Example"}, NewCommand(CommandSpec[outer]{Name: "run", Flags: flags, Run: func(_ Invocation, input outer) Outcome {
+		var m middle
+		if err := input.values.ApplyTo(&m, inner...); err != nil {
+			return Failure("middle replay failed").WithCause(err)
+		}
+		captured = m.values
+		return Success()
+	}}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, args := range [][]string{
+		{"run", "--gamma=c1", "--alpha=a1", "--beta=b1", "--alpha=a2", "--gamma=c2", "--beta=b2"},
+		{"run"},
+	} {
+		result := app.Execute(t.Context(), args, Streams{})
+		if result.Status != 0 {
+			t.Fatalf("capture=%#v", result)
+		}
+		for _, tc := range []struct {
+			name  string
+			flags []Flag[occurrenceInput]
+			want  []string
+		}{
+			{"all reversed", []Flag[occurrenceInput]{c, b, a}, []string{"gamma=c1", "alpha=a1", "beta=b1", "alpha=a2", "gamma=c2", "beta=b2"}},
+			{"subset", []Flag[occurrenceInput]{a, c}, []string{"gamma=c1", "alpha=a1", "alpha=a2", "gamma=c2"}},
+			{"single", []Flag[occurrenceInput]{b}, []string{"beta=b1", "beta=b2"}},
+			{"duplicate handle", []Flag[occurrenceInput]{b, a, b}, []string{"alpha=a1", "beta=b1", "beta=b1", "alpha=a2", "beta=b2", "beta=b2"}},
+			{"empty", nil, nil},
+		} {
+			for _, suppliedOnly := range []bool{false, true} {
+				var got occurrenceInput
+				if suppliedOnly {
+					err = captured.ApplySuppliedTo(&got, tc.flags...)
+				} else {
+					err = captured.ApplyTo(&got, tc.flags...)
+				}
+				want := tc.want
+				if len(args) == 1 {
+					want = nil
+				}
+				if err != nil || !reflect.DeepEqual(got.events, want) {
+					t.Fatalf("%s suppliedOnly=%t args=%v events=%v want=%v err=%v", tc.name, suppliedOnly, args, got.events, want, err)
+				}
+			}
+		}
+	}
+	if calls != 6 {
+		t.Fatalf("replay reconverted captured input: %d parses", calls)
+	}
+}