Merge branch 'main' into fix/fish-dynamic-completions

Author: TimSoethout

.github/workflows/test.yml

@@ -53,7 +53,7 @@ jobs:
         run: make v3diff
 
       - if: success() && matrix.go == 'stable' && matrix.os == 'ubuntu-24.04'
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v6
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           fail_ci_if_error: true

command.go

@@ -582,19 +582,14 @@ func (cmd *Command) NArg() int {
 
 func (cmd *Command) runFlagActions(ctx context.Context) error {
 	tracef("runFlagActions")
-	for fl := range cmd.setFlags {
-		/*tracef("checking %v:%v", fl.Names(), fl.IsSet())
-		if !fl.IsSet() {
-			continue
-		}*/
-
-		//if pf, ok := fl.(LocalFlag); ok && !pf.IsLocal() {
-		//	continue
-		//}
-
-		if af, ok := fl.(ActionableFlag); ok {
-			if err := af.RunAction(ctx, cmd); err != nil {
-				return err
+	// run the flag actions in the same order that they are defined
+	// to maintain consistency.
+	for _, fl := range cmd.appliedFlags {
+		if _, inSet := cmd.setFlags[fl]; inSet {
+			if af, ok := fl.(ActionableFlag); ok {
+				if err := af.RunAction(ctx, cmd); err != nil {
+					return err
+				}
 			}
 		}
 	}

command_parse.go

@@ -80,7 +80,8 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 
 		firstArg := strings.TrimSpace(rargs[0])
 		if len(firstArg) == 0 {
-			break
+			posArgs = append(posArgs, rargs[0])
+			continue
 		}
 
 		// stop parsing once we see a "--"
@@ -163,8 +164,8 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 
 			tracef("processing non bool flag (fName=%[1]q)", flagName)
 			// not a bool flag so need to get the next arg
-			if flagVal == "" {
-				if len(rargs) == 1 || valFromEqual {
+			if flagVal == "" && !valFromEqual {
+				if len(rargs) == 1 {
 					return &stringSliceArgs{posArgs}, fmt.Errorf("%s%s", argumentNotProvidedErrMsg, firstArg)
 				}
 				flagVal = rargs[1]

command_test.go

@@ -823,7 +823,7 @@ var defaultCommandTests = []struct {
 	{"f", "", nil, true},
 	{"", "foobar", nil, true},
 	{"", "", nil, true},
-	{" ", "", nil, true},
+	{" ", "", nil, false},
 	{"bat", "batbaz", nil, true},
 	{"nothing", "batbaz", nil, true},
 	{"nothing", "", nil, false},
@@ -911,10 +911,10 @@ var defaultCommandSubCommandTests = []struct {
 	{"", "carly", "foobar", true},
 	{"", "jimmers", "foobar", false},
 	{"", "jimmers", "", false},
-	{" ", "jimmers", "foobar", true},
+	{" ", "jimmers", "foobar", false},
 	{"", "", "", true},
-	{" ", "", "", true},
-	{" ", "j", "", true},
+	{" ", "", "", false},
+	{" ", "j", "", false},
 	{"bat", "", "batbaz", false},
 	{"nothing", "", "batbaz", false},
 	{"nothing", "", "", false},
@@ -977,10 +977,10 @@ var defaultCommandFlagTests = []struct {
 	{"", "--carly=derp", "foobar", true},
 	{"", "-j", "foobar", true},
 	{"", "-j", "", true},
-	{" ", "-j", "foobar", true},
+	{" ", "-j", "foobar", false},
 	{"", "", "", true},
-	{" ", "", "", true},
-	{" ", "-j", "", true},
+	{" ", "", "", false},
+	{" ", "-j", "", false},
 	{"bat", "", "batbaz", false},
 	{"nothing", "", "batbaz", false},
 	{"nothing", "", "", false},
@@ -2185,6 +2185,54 @@ func TestCommand_OrderOfOperations(t *testing.T) {
 	})
 }
 
+func TestFlagActionOrder(t *testing.T) {
+	tests := []struct {
+		Name string
+		Args []string
+	}{
+		{
+			Name: "abc",
+			Args: []string{"", "--a", "--b", "--c"},
+		},
+		{
+			Name: "bca",
+			Args: []string{"", "--b", "--c", "--a"},
+		},
+		{
+			Name: "cba",
+			Args: []string{"", "--c", "--b", "--a"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			str := ""
+			action := func(name string) func(context.Context, *Command, bool) error {
+				return func(_ context.Context, _ *Command, _ bool) error {
+					str += name
+					return nil
+				}
+			}
+			cmd := &Command{
+				Flags: []Flag{
+					&BoolFlag{Name: "a", Action: action("a")},
+					&BoolFlag{Name: "b", Action: action("b")},
+					&BoolFlag{Name: "c", Action: action("c")},
+				},
+				Action: func(_ context.Context, cmd *Command) error {
+					return nil
+				},
+			}
+
+			err := cmd.Run(buildTestContext(t), tt.Args)
+			require.NoError(t, err)
+
+			if str != "abc" {
+				t.Errorf("expected 'abc' got '%s'", str)
+			}
+		})
+	}
+}
+
 func TestCommand_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
 	subcommandHelpTopics := [][]string{
 		{"foo", "--help"},
@@ -2801,12 +2849,12 @@ func TestFlagAction(t *testing.T) {
 		{
 			name: "flag_string_error",
 			args: []string{"app", "--f_string="},
-			err:  "flag needs an argument: --f_string=",
+			err:  "empty string",
 		},
 		{
 			name: "flag_string_error2",
 			args: []string{"app", "--f_string=", "--f_bool"},
-			err:  "flag needs an argument: --f_string=",
+			err:  "empty string",
 		},
 		{
 			name: "flag_string_slice",
@@ -3105,6 +3153,39 @@ func TestFlagAction(t *testing.T) {
 	}
 }
 
+func TestLocalSliceFlagAccumulation(t *testing.T) {
+	var got []string
+
+	app := &Command{
+		Name: "app",
+		Commands: []*Command{
+			{
+				Name: "sub",
+				Flags: []Flag{
+					&StringSliceFlag{
+						Name:        "paths",
+						Aliases:     []string{"p"},
+						Local:       true,
+						Destination: &got,
+					},
+				},
+				Action: func(_ context.Context, cmd *Command) error {
+					return nil
+				},
+			},
+		},
+	}
+
+	err := app.Run(context.Background(), []string{"app", "sub", "-p", "/a", "-p", "/b", "-p", "/c"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(got) != 3 {
+		t.Errorf("expected 3 values, got %d: %v", len(got), got)
+	}
+}
+
 func TestLocalFlagError(t *testing.T) {
 	var topInt int64
 
@@ -5542,3 +5623,86 @@ func TestCommand_ExclusiveFlagsPersistent(t *testing.T) {
 		})
 	}
 }
+
+func TestEmptyPositionalArgs(t *testing.T) {
+	testCases := []struct {
+		Name     string
+		Args     []string
+		Expected []string
+	}{
+		{
+			Name:     "empty arg between values",
+			Args:     []string{"app", "hello", "", "world"},
+			Expected: []string{"hello", "", "world"},
+		},
+		{
+			Name:     "empty arg at start",
+			Args:     []string{"app", "", "hello"},
+			Expected: []string{"", "hello"},
+		},
+		{
+			Name:     "whitespace-only arg",
+			Args:     []string{"app", "hello", "  ", "world"},
+			Expected: []string{"hello", "  ", "world"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.Name, func(t *testing.T) {
+			var args []string
+
+			cmd := &Command{
+				Action: func(_ context.Context, cmd *Command) error {
+					args = cmd.Args().Slice()
+					return nil
+				},
+			}
+
+			err := cmd.Run(buildTestContext(t), tc.Args)
+			assert.NoError(t, err)
+			assert.Equal(t, tc.Expected, args)
+		})
+	}
+}
+
+func TestFlagEqualsEmptyValue(t *testing.T) {
+	t.Run("--flag= sets empty string", func(t *testing.T) {
+		var val string
+
+		cmd := &Command{
+			Flags: []Flag{
+				&StringFlag{
+					Name:        "name",
+					Destination: &val,
+				},
+			},
+		}
+
+		err := cmd.Run(buildTestContext(t), []string{"app", "--name="})
+		assert.NoError(t, err)
+		assert.Equal(t, "", val)
+	})
+
+	t.Run("--flag= does not consume next positional arg", func(t *testing.T) {
+		var val string
+		var args []string
+
+		cmd := &Command{
+			Flags: []Flag{
+				&StringFlag{
+					Name:        "name",
+					Destination: &val,
+				},
+			},
+			Action: func(_ context.Context, cmd *Command) error {
+				args = cmd.Args().Slice()
+				return nil
+			},
+		}
+
+		err := cmd.Run(buildTestContext(t), []string{"app", "--name=", "positional"})
+		assert.NoError(t, err)
+		assert.Equal(t, "", val)
+		assert.Equal(t, []string{"positional"}, args)
+	})
+}

flag_impl.go

@@ -185,7 +185,7 @@ func (f *FlagBase[T, C, V]) Set(_ string, val string) error {
 	// lots of units tests prior to persistent flags assumed that the
 	// flag can be applied to different flag sets multiple times while still
 	// keeping the env set.
-	if !f.applied || f.Local {
+	if !f.applied {
 		if err := f.PreParse(); err != nil {
 			return err
 		}

mkdocs-requirements.txt

@@ -1,5 +1,5 @@
 mkdocs-git-revision-date-localized-plugin==1.5.1
-mkdocs-material==9.7.5
+mkdocs-material==9.7.6
 mkdocs==1.6.1
-mkdocs-redirects==1.2.2
-pygments==2.19.2
+mkdocs-redirects==1.2.3
+pygments==2.20.0