derivepassphrase.git

@@ -719,10 +719,17 @@ class Strategies(types.SimpleNamespace):

     @staticmethod

     def option_and_argument(

         opt: cli_machinery.CLIOption,

+        /,

         free_arguments_strategy: strategies.SearchStrategy[str] | None = None,

+        *,

+        normalized: bool = True,

     ) -> strategies.SearchStrategy[list[str]]:

         # shrink to less complex option names

-        option_names = sorted(opt.names, key=_name_complexity)

+        option_names = (

+            [opt.names[0]]

+            if normalized

+            else sorted(opt.names, key=_name_complexity)

+        )

         option_strategy = strategies.sampled_from(option_names)

         if not isinstance(opt.has_argument, bool):

             # shrink to less complex arguments

@@ -789,9 +796,12 @@ class Strategies(types.SimpleNamespace):

     def arrange_options(

         *options: cli_machinery.CLIOption,

         free_arguments_strategy: strategies.SearchStrategy[str] | None = None,

+        normalized: bool = True,

     ) -> strategies.SearchStrategy[list[list[str]]]:

         pairs_strategies = [

-            Strategies.option_and_argument(opt, free_arguments_strategy)

+            Strategies.option_and_argument(

+                opt, free_arguments_strategy, normalized=normalized

+            )

             for opt in options

         ]

         return strategies.tuples(*pairs_strategies).map(list)

@@ -810,12 +820,15 @@ class Strategies(types.SimpleNamespace):

     def choose_options(

         *options: cli_machinery.CLIOption,

         free_arguments_strategy: strategies.SearchStrategy[str] | None = None,

+        normalized: bool = True,

     ) -> strategies.SearchStrategy[list[list[str]]]:

         def _option_and_argument(

             opt: cli_machinery.CLIOption,

             /,

         ) -> strategies.SearchStrategy[list[str]]:

-            return Strategies.option_and_argument(opt, free_arguments_strategy)

+            return Strategies.option_and_argument(

+                opt, free_arguments_strategy, normalized=normalized

+            )

         return strategies.lists(

             Strategies.choose_option(options).flatmap(_option_and_argument),

@@ -827,17 +840,22 @@ class Strategies(types.SimpleNamespace):

         *options: cli_machinery.CLIOption,

         free_arguments_strategy: strategies.SearchStrategy[str] | None = None,

         in_order: bool = True,

+        normalized: bool = True,

     ) -> strategies.SearchStrategy[list[list[str]]]:

         if not options:  # pragma: no cover [failsafe]

             msg = "No options given!"

             raise ValueError(msg)

         return (

             Strategies.arrange_options(

-                *options, free_arguments_strategy=free_arguments_strategy

+                *options,

+                free_arguments_strategy=free_arguments_strategy,

+                normalized=normalized,

             )

             if in_order

             else Strategies.choose_options(

-                *options, free_arguments_strategy=free_arguments_strategy

+                *options,

+                free_arguments_strategy=free_arguments_strategy,

+                normalized=normalized,

             )

         )

@@ -1133,6 +1151,7 @@ class Strategies(types.SimpleNamespace):

                         Strategies.any_option_and_argument_pairs(

                             *options,

                             in_order=True,

+                            normalized=normalized,

                         ),

                         normalized=normalized,

                     ),

@@ -1141,6 +1160,12 @@ class Strategies(types.SimpleNamespace):

                 if options

                 else []

             )

+            command_line.extend(

+                ["--"]

+                if normalized

+                or draw(strategies.booleans(), "end_of_options_marker")

+                else []

+            )

             if isinstance(

                 subcommand_or_arguments,

                 (

@@ -1209,6 +1234,7 @@ class Strategies(types.SimpleNamespace):

                     Strategies.any_option_and_argument_pairs(

                         *options,

                         in_order=True,

+                        normalized=False,

                     ),

                     f"section {i} raw option/argument pairs",

                 )

@@ -1275,6 +1301,121 @@ class Strategies(types.SimpleNamespace):

         result = cli_machinery.ParseSuccess(new_state, None)

         return ParseStateAndExpectedResult(old_state, result)

+    @staticmethod

+    @strategies.composite

+    def scan_for_eager_options_parser_states(

+        draw: strategies.DrawFn,

+        /,

+        subcommand_and_symbolic_command_line: tuple[

+            cli_machinery.CLISubcommand,

+            list[

+                tuple[

+                    tuple[cli_machinery.CLIOption, ...],

+                    tuple[cli_machinery.CLIArgument, ...]

+                    | cli_machinery.CLISubcommand,

+                ]

+            ],

+        ]

+        | None = None,

+        *,

+        allow_eager: bool = True,

+        max_option_groups: int = NUM_NAMES,

+        max_positionals: int = NUM_NAMES,

+    ) -> ParseStateAndExpectedResult:

+        subcommand, command_line_symbolic_sections = (

+            subcommand_and_symbolic_command_line

+            if subcommand_and_symbolic_command_line is not None

+            else draw(

+                Strategies.subcommand_and_symbolic_command_line(

+                    allow_eager=allow_eager,

+                    max_option_groups=max_option_groups,

+                    max_positionals=max_positionals,

+                ),

+                "subcommand/symbolic command-line",

+            )

+        )

+        command_line: list[str] = []

+        equivalent_command_line: list[str] = []

+        parse_result: str | None = None

+        for i, section in enumerate(command_line_symbolic_sections):

+            options, subcommand_or_arguments = section

+            if options:  # pragma: no branch

+                option_and_argument_pairs = draw(

+                    Strategies.any_option_and_argument_pairs(

+                        *options,

+                        in_order=True,

+                        normalized=True,

+                    ),

+                    f"section {i} raw option/argument pairs",

+                )

+                drawn_options_and_arguments = (

+                    draw(

+                        Strategies.any_options(

+                            strategies.just(option_and_argument_pairs),

+                            normalized=True,

+                        ),

+                        f"section {i} options",

+                    )

+                    if options

+                    else []

+                )

+                command_line.extend(drawn_options_and_arguments)

+                if i == 0:

+                    assert len(option_and_argument_pairs) == len(options)

+                    for opt, pair in zip(options, option_and_argument_pairs):

+                        token = (

+                            f"{opt.names[0]}={pair[1]}"

+                            if len(pair) > 1

+                            else opt.names[0]

+                        )

+                        if opt.eager:

+                            equivalent_command_line.clear()

+                            parse_result = token

+                        equivalent_command_line.append(token)

+                        if parse_result is not None:

+                            break

+                elif parse_result is None:

+                    equivalent_command_line.extend(drawn_options_and_arguments)

+            if parse_result is not None:

+                pass

+            elif isinstance(

+                subcommand_or_arguments,

+                (

+                    cli_machinery.CLITerminalSubcommand,

+                    cli_machinery.CLICompositeSubcommand,

+                ),

+            ):

+                command_line.append("--")

+                equivalent_command_line.append("--")

+                subcommand_name = subcommand_or_arguments.names[0]

+                command_line.append(subcommand_name)

+                equivalent_command_line.append(subcommand_name)

+            else:

+                command_line.append("--")

+                equivalent_command_line.append("--")

+                arguments_strategies = [

+                    strategies.sampled_from(arg.choices)

+                    if arg.choices is not None

+                    else Strategies.WORDS

+                    for arg in subcommand_or_arguments

+                ]

+                argument_values = draw(

+                    strategies.tuples(*arguments_strategies),

+                    f"section {i} arguments",

+                )

+                command_line.extend(argument_values)

+                equivalent_command_line.extend(argument_values)

+        old_state = cli_machinery.ParseState(tuple(command_line), subcommand)

+        new_state = cli_machinery.ParseState(

+            tuple(equivalent_command_line), subcommand

+        )

+        result = (

+            cli_machinery.ParseEarlyExit(new_state, parse_result)

+            if parse_result is not None

+            else cli_machinery.ParseSuccess(new_state, parse_result)

+        )

+        return ParseStateAndExpectedResult(old_state, result)

+

 strategies.register_type_strategy(

     cli_machinery.CLIOption,

@@ -1547,6 +1688,43 @@ class Test001VersionOutputParser:

 class Test010CLIMachinery:

     """Tests for the CLI machinery."""

+    @hypothesis.given(starting_state=Strategies.parse_states(normalized=True))

+    def test_normalized_starting_states_are_normalized(

+        self,

+        starting_state: cli_machinery.ParseState,

+    ) -> None:

+        command_line = starting_state.command_line

+        canon_map = starting_state.subcommand.canon_map

+        for token in command_line:

+            tokentype = cli_machinery.CommandLineTokenType.classify(token)

+            assert (

+                tokentype != cli_machinery.CommandLineTokenType.SHORT_OPTION

+            ), f"Short option {token!r} not allowed in normalized command-line"

+            assert (

+                tokentype != cli_machinery.CommandLineTokenType.POSITIONAL

+            ), (

+                f"Positional argument {token!r} not allowed "

+                "in normalized command-line without preceding "

+                "end-of-options token"

+            )

+            if tokentype == cli_machinery.CommandLineTokenType.END_OF_OPTIONS:

+                break

+            assert tokentype == cli_machinery.CommandLineTokenType.LONG_OPTION

+            if "=" not in token:

+                opt = cast("cli_machinery.CLIOption", canon_map[token])

+                assert not opt.has_argument, (

+                    f"Separated argument for option {token!r}=... not allowed "

+                    "in normalized command-line"

+                )

+

+    @hypothesis.given(starting_state=Strategies.parse_states(normalized=True))

+    def test_normalize_options_stage_on_normalized_command_lines(

+        self,

+        starting_state: cli_machinery.ParseState,

+    ) -> None:

+        result = cli_machinery.normalize_options(starting_state)

+        assert result == cli_machinery.ParseResult.unit(starting_state)

+

     @hypothesis.given(data_tuple=Strategies.normalizable_parser_states())

     def test_normalize_options_stage(

         self,

@@ -1558,6 +1736,19 @@ class Test010CLIMachinery:

         assert actual_result.state == data_tuple.expected_result.state

         assert actual_result == data_tuple.expected_result

+    @hypothesis.given(

+        data_tuple=Strategies.scan_for_eager_options_parser_states()

+    )

+    def test_scan_for_eager_options_parser_stage(

+        self,

+        data_tuple: ParseStateAndExpectedResult,

+    ) -> None:

+        actual_result = cli_machinery.scan_for_eager_options(

+            data_tuple.starting_state

+        )

+        assert actual_result.state == data_tuple.expected_result.state

+        assert actual_result == data_tuple.expected_result

+

 class TestHelpOutput:

     """Tests for all command-line interfaces' `--help` output."""