oneOfArgs now tries to return the first error which is not an arity error.

Author: robinheghan

src/CLI/Parser.gren

@@ -485,7 +485,7 @@ noArgs =
         { description = ""
         , parseFn = \args ->
             if Array.length args /= 0 then
-                Err <| ArgumentParserWrongArity { expected = 0, actual = (Array.length args) }
+                Err <| ArgumentParserWrongArity { expected = 0, actual = Array.length args }
 
             else
                 Ok {}
@@ -644,7 +644,27 @@ oneOfArgs argParsers =
                     Ok result
 
                 Nothing ->
-                    Array.first parseResults
+                    parseResults
+                        |> Array.findFirst
+                            (\result ->
+                                when result is
+                                    Ok _ ->
+                                        False
+
+                                    Err (ArgumentParserWrongArity _) ->
+                                        False
+
+                                    _ ->
+                                        True
+                            )
+                        |> (\maybeErr ->
+                            when maybeErr is
+                                Nothing ->
+                                    Array.first parseResults
+
+                                Just err ->
+                                    Just err.value
+                        )
                         |> Maybe.withDefault 
                             (Err <| ArgumentParserInvalidArgument
                                 { argument = String.join " " args

tests/src/Test/CLI/Parser.gren

@@ -272,18 +272,18 @@ tests =
                     testCmdOneOfArgs =
                         cmdBuilder
                             (Parser.oneOfArgs
-                                [ Parser.twoArgs
-                                    (\path file -> 
-                                        { path = path, file = file }
-                                    )
-                                    Parser.pathParser
-                                    Parser.grenFileParser
-                                , Parser.noArgs
+                                [ Parser.noArgs
                                     |> Parser.mapArgs (\{} ->
                                             { path = Path.fromPosixString ""
                                             , file = Path.fromPosixString ""
                                             }
                                         )
+                                , Parser.twoArgs
+                                    (\path file -> 
+                                        { path = path, file = file }
+                                    )
+                                    Parser.pathParser
+                                    Parser.grenFileParser
                                 ]
                             )
                             testFlags
@@ -314,10 +314,17 @@ tests =
                     runCommand testCmdOneOfArgs [ "make", "src/Dest" ]
                         |> Expect.equal
                             (Parser.BadArguments <| Parser.ArgumentParserWrongArity 
-                                { expected = 2
+                                { expected = 0
                                 , actual = 1
                                 }
                             )
+                , test "Tries to find error of matching arity" <| \{} ->
+                    when runCommand testCmdOneOfArgs [ "make", "out.txt", "src/Dest" ] is
+                        Parser.BadArguments (Parser.ArgumentParserInvalidArgument _) ->
+                            Expect.pass
+
+                        _ ->
+                            Expect.fail "Expected parsing to fail with an invalid argument error"
                 ]
             ]
         , describe "Flags"