derivepassphrase.git

@@ -952,7 +952,7 @@ def validate_length(

     return int_value

-def version_option_callback(

+def common_version_output(

     ctx: click.Context,

     param: click.Parameter,

     value: bool,  # noqa: FBT001

@@ -960,32 +960,6 @@ def version_option_callback(

     del param

     if value and not ctx.resilient_parsing:

         major_dependencies: list[str] = []

-        derivation_schemes = {'vault': True}

-        foreign_configuration_formats = {

-            'vault storeroom': False,

-            'vault v0.2': False,

-            'vault v0.3': False,

-        }

-        known_extras = {

-            'export': False,

-        }

-        try:

-            from derivepassphrase.exporter import storeroom, vault_native  # noqa: I001,PLC0415

-

-            foreign_configuration_formats[

-                'vault storeroom'

-            ] = not storeroom.STUBBED

-            foreign_configuration_formats[

-                'vault v0.2'

-            ] = not vault_native.STUBBED

-            foreign_configuration_formats[

-                'vault v0.3'

-            ] = not vault_native.STUBBED

-            known_extras['export'] = (

-                not storeroom.STUBBED and not vault_native.STUBBED

-            )

-        except ModuleNotFoundError:  # pragma: no cover

-            pass

         try:

             cryptography_version = importlib.metadata.version('cryptography')

         except ModuleNotFoundError:

@@ -1011,24 +985,14 @@ def version_option_callback(

                 ),

                 color=ctx.color,

             )

-        click.echo()

-        version_info_types = {

-            _msg.Label.SUPPORTED_DERIVATION_SCHEMES: [

-                k for k, v in derivation_schemes.items() if v

-            ],

-            _msg.Label.KNOWN_DERIVATION_SCHEMES: [

-                k for k, v in derivation_schemes.items() if not v

-            ],

-            _msg.Label.SUPPORTED_FOREIGN_CONFIGURATION_FORMATS: [

-                k for k, v in foreign_configuration_formats.items() if v

-            ],

-            _msg.Label.KNOWN_FOREIGN_CONFIGURATION_FORMATS: [

-                k for k, v in foreign_configuration_formats.items() if not v

-            ],

-            _msg.Label.ENABLED_PEP508_EXTRAS: [

-                k for k, v in known_extras.items() if v

-            ],

-        }

+

+

+def print_version_info_types(

+    version_info_types: dict[_msg.Label, list[str]],

+    /,

+    *,

+    ctx: click.Context,

+) -> None:

     for message_label, item_list in version_info_types.items():

         if item_list:

             current_length = len(str(_msg.TranslatedString(message_label)))

@@ -1038,21 +1002,14 @@ def version_option_callback(

                 space = ' '

                 punctuation = '.' if i == n else ','

                 if (

-                        current_length

-                        + len(space)

-                        + len(item)

-                        + len(punctuation)

+                    current_length + len(space) + len(item) + len(punctuation)

                     <= VERSION_OUTPUT_WRAPPING_WIDTH

                 ):

-                        current_length += (

-                            len(space) + len(item) + len(punctuation)

-                        )

+                    current_length += len(space) + len(item) + len(punctuation)

                     piece = f'{space}{item}{punctuation}'

                 else:

                     space = '    '

-                        current_length = (

-                            len(space) + len(item) + len(punctuation)

-                        )

+                    current_length = len(space) + len(item) + len(punctuation)

                     piece = f'\n{space}{item}{punctuation}'

                 formatted_item_list_pieces.append(piece)

             click.echo(

@@ -1065,10 +1022,118 @@ def version_option_callback(

                 ]),

                 color=ctx.color,

             )

+

+

+def derivepassphrase_version_option_callback(

+    ctx: click.Context,

+    param: click.Parameter,

+    value: bool,  # noqa: FBT001

+) -> None:

+    if value and not ctx.resilient_parsing:

+        common_version_output(ctx, param, value)

+        derivation_schemes = {'vault': True}

+        supported_subcommands = {'export', 'vault'}

+        click.echo()

+        version_info_types = {

+            _msg.Label.SUPPORTED_DERIVATION_SCHEMES: [

+                k for k, v in derivation_schemes.items() if v

+            ],

+            _msg.Label.KNOWN_DERIVATION_SCHEMES: [

+                k for k, v in derivation_schemes.items() if not v

+            ],

+            _msg.Label.SUPPORTED_SUBCOMMANDS: sorted(supported_subcommands),

+        }

+        print_version_info_types(version_info_types, ctx=ctx)

         ctx.exit()

-def version_option(f: Callable[P, R]) -> Callable[P, R]:

+def export_version_option_callback(

+    ctx: click.Context,

+    param: click.Parameter,

+    value: bool,  # noqa: FBT001

+) -> None:

+    if value and not ctx.resilient_parsing:

+        common_version_output(ctx, param, value)

+        supported_subcommands = {'vault'}

+        foreign_configuration_formats = {

+            'vault storeroom': False,

+            'vault v0.2': False,

+            'vault v0.3': False,

+        }

+        click.echo()

+        version_info_types = {

+            _msg.Label.KNOWN_FOREIGN_CONFIGURATION_FORMATS: [

+                k for k, v in foreign_configuration_formats.items() if not v

+            ],

+            _msg.Label.SUPPORTED_SUBCOMMANDS: sorted(supported_subcommands),

+        }

+        print_version_info_types(version_info_types, ctx=ctx)

+        ctx.exit()

+

+

+def export_vault_version_option_callback(

+    ctx: click.Context,

+    param: click.Parameter,

+    value: bool,  # noqa: FBT001

+) -> None:

+    if value and not ctx.resilient_parsing:

+        common_version_output(ctx, param, value)

+        foreign_configuration_formats = {

+            'vault storeroom': False,

+            'vault v0.2': False,

+            'vault v0.3': False,

+        }

+        known_extras = {

+            'export': False,

+        }

+        try:

+            from derivepassphrase.exporter import storeroom, vault_native  # noqa: I001,PLC0415

+

+            foreign_configuration_formats[

+                'vault storeroom'

+            ] = not storeroom.STUBBED

+            foreign_configuration_formats[

+                'vault v0.2'

+            ] = not vault_native.STUBBED

+            foreign_configuration_formats[

+                'vault v0.3'

+            ] = not vault_native.STUBBED

+            known_extras['export'] = (

+                not storeroom.STUBBED and not vault_native.STUBBED

+            )

+        except ModuleNotFoundError:  # pragma: no cover

+            pass

+        click.echo()

+        version_info_types = {

+            _msg.Label.SUPPORTED_FOREIGN_CONFIGURATION_FORMATS: [

+                k for k, v in foreign_configuration_formats.items() if v

+            ],

+            _msg.Label.KNOWN_FOREIGN_CONFIGURATION_FORMATS: [

+                k for k, v in foreign_configuration_formats.items() if not v

+            ],

+            _msg.Label.ENABLED_PEP508_EXTRAS: [

+                k for k, v in known_extras.items() if v

+            ],

+        }

+        print_version_info_types(version_info_types, ctx=ctx)

+        ctx.exit()

+

+

+def vault_version_option_callback(

+    ctx: click.Context,

+    param: click.Parameter,

+    value: bool,  # noqa: FBT001

+) -> None:

+    if value and not ctx.resilient_parsing:

+        common_version_output(ctx, param, value)

+        ctx.exit()

+

+

+def version_option(

+    version_option_callback: Callable[

+        [click.Context, click.Parameter, Any], Any

+    ],

+) -> Callable[[Callable[P, R]], Callable[P, R]]:

     return click.option(

         '--version',

         is_flag=True,

@@ -1077,7 +1142,7 @@ def version_option(f: Callable[P, R]) -> Callable[P, R]:

         callback=version_option_callback,

         cls=StandardOption,

         help=_msg.TranslatedString(_msg.Label.VERSION_OPTION_HELP_TEXT),

-    )(f)

+    )

 color_forcing_pseudo_option = click.option(

@@ -1327,6 +1327,15 @@ class Label(enum.Enum):

         'Supported foreign configuration formats:',

     )

     """"""

+    SUPPORTED_SUBCOMMANDS = commented(

+        'This is part of the version output, emitting lists of supported '

+        'subcommands.  A comma-separated English list '

+        'of items follows, with standard English punctuation.',

+    )(

+        'Label :: Info Message:: Table row header',

+        'Supported subcommands:',

+    )

+    """"""

     CONFIRM_THIS_CHOICE_PROMPT_TEXT = commented(

         'There is no support for "yes" or "no" in other languages '

         'than English, so it is advised that your translation makes it '

@@ -58,7 +58,9 @@ VERSION = _internals.VERSION

         _msg.TranslatedString(_msg.Label.DERIVEPASSPHRASE_03),

     ),

 )

-@cli_machinery.version_option

+@cli_machinery.version_option(

+    cli_machinery.derivepassphrase_version_option_callback

+)

 @cli_machinery.color_forcing_pseudo_option

 @cli_machinery.standard_logging_options

 @click.pass_context

@@ -113,7 +115,7 @@ def derivepassphrase(ctx: click.Context, /) -> None:

         _msg.TranslatedString(_msg.Label.DERIVEPASSPHRASE_EXPORT_03),

     ),

 )

-@cli_machinery.version_option

+@cli_machinery.version_option(cli_machinery.export_version_option_callback)

 @cli_machinery.color_forcing_pseudo_option

 @cli_machinery.standard_logging_options

 @click.pass_context

@@ -204,7 +206,9 @@ def derivepassphrase_export(ctx: click.Context, /) -> None:

     ),

     cls=cli_machinery.StandardOption,

 )

-@cli_machinery.version_option

+@cli_machinery.version_option(

+    cli_machinery.export_vault_version_option_callback

+)

 @cli_machinery.color_forcing_pseudo_option

 @cli_machinery.standard_logging_options

 @click.argument(

@@ -610,7 +614,7 @@ def derivepassphrase_export_vault(

     ),

     cls=cli_machinery.CompatibilityOption,

 )

-@cli_machinery.version_option

+@cli_machinery.version_option(cli_machinery.vault_version_option_callback)

 @cli_machinery.color_forcing_pseudo_option

 @cli_machinery.standard_logging_options

 @click.argument(

@@ -85,6 +85,7 @@ class VersionOutputData(NamedTuple):

     derivation_schemes: dict[str, bool]

     foreign_configuration_formats: dict[str, bool]

     extras: frozenset[str]

+    subcommands: frozenset[str]

 PASSPHRASE_GENERATION_OPTIONS: list[tuple[str, ...]] = [

@@ -349,15 +350,15 @@ def parse_version_output(  # noqa: C901

     The version output contains two paragraphs.  The first paragraph

     details the version number, and the version number of any major

     libraries in use.  The second paragraph details known and supported

-    passphrase derivation schemes, foreign configuration formats, and

-    PEP 508 package extras.  For the schemes and formats, there is

-    a "supported" line for supported items, and a "known" line for known

-    but currently unsupported items (usually because of missing

-    dependencies), either of which may be empty and thus omitted.  For

-    extras, only active items are shown, and there is a separate message

-    for the "no extras active" case.  Item lists may be spilled across

-    multiple lines, but only at item boundaries, and the continuation

-    lines are then indented.

+    passphrase derivation schemes, foreign configuration formats,

+    subcommands and PEP 508 package extras.  For the schemes and

+    formats, there is a "supported" line for supported items, and

+    a "known" line for known but currently unsupported items (usually

+    because of missing dependencies), either of which may be empty and

+    thus omitted.  For extras, only active items are shown, and there is

+    a separate message for the "no extras active" case.  Item lists may

+    be spilled across multiple lines, but only at item boundaries, and

+    the continuation lines are then indented.

     Args:

         text:

@@ -389,8 +390,8 @@ def parse_version_output(  # noqa: C901

     if paragraph:  # pragma: no branch

         paragraphs.append(paragraph.copy())

         paragraph.clear()

-    assert len(paragraphs) == 2, (

-        f'expected exactly two lines of version output: {paragraphs!r}'

+    assert paragraphs, (

+        f'expected at least one paragraph of version output: {paragraphs!r}'

     )

     assert prog_name is None or prog_name in paragraphs[0][0], (

         f'first version output line should mention '

@@ -400,9 +401,17 @@ def parse_version_output(  # noqa: C901

         f'first version output line should mention the version number '

         f'{version}: {paragraphs[0][0]!r}'

     )

-    schemas: dict[str, bool] = {}

+    schemes: dict[str, bool] = {}

     formats: dict[str, bool] = {}

+    subcommands: set[str] = set()

     extras: set[str] = set()

+    if len(paragraphs) < 2:

+        return VersionOutputData(

+            derivation_schemes=schemes,

+            foreign_configuration_formats=formats,

+            subcommands=frozenset(subcommands),

+            extras=frozenset(extras),

+        )

     for line in paragraphs[1]:

         line_type, _, value = line.partition(':')

         if line_type == line:

@@ -416,16 +425,23 @@ def parse_version_output(  # noqa: C901

             elif line_type == 'Known foreign configuration formats':

                 formats[item] = False

             elif line_type == 'Supported derivation schemes':

-                schemas[item] = True

+                schemes[item] = True

             elif line_type == 'Known derivation schemes':

-                schemas[item] = False

+                schemes[item] = False

+            elif line_type == 'Supported subcommands':

+                subcommands.add(item)

             elif line_type == 'PEP 508 extras':

                 extras.add(item)

             else:

                 raise AssertionError(  # noqa: TRY003

                     f'Unknown version info line type: {line_type!r}'  # noqa: EM102

                 )

-    return VersionOutputData(schemas, formats, frozenset(extras))

+    return VersionOutputData(

+        derivation_schemes=schemes,

+        foreign_configuration_formats=formats,

+        subcommands=frozenset(subcommands),

+        extras=frozenset(extras),

+    )

 def bash_format(item: click.shell_completion.CompletionItem) -> str:

@@ -1451,7 +1467,6 @@ class Parametrize(types.SimpleNamespace):

 derivepassphrase 0.4.0

 Using cryptography 44.0.0

-Supported derivation schemes: vault.

 Supported foreign configuration formats: vault storeroom, vault v0.2,

     vault v0.3.

 PEP 508 extras: export.

@@ -1459,12 +1474,13 @@ PEP 508 extras: export.

                 'derivepassphrase',

                 '0.4.0',

                 VersionOutputData(

-                    derivation_schemes={'vault': True},

+                    derivation_schemes={},

                     foreign_configuration_formats={

                         'vault storeroom': True,

                         'vault v0.2': True,

                         'vault v0.3': True,

                     },

+                    subcommands=frozenset(),

                     extras=frozenset({'export'}),

                 ),

                 id='derivepassphrase-0.4.0-export',

@@ -1475,6 +1491,7 @@ derivepassphrase 0.5

 Supported derivation schemes: vault.

 Known foreign configuration formats: vault storeroom, vault v0.2, vault v0.3.

+Supported subcommands: export, vault.

 No PEP 508 extras are active.

 """,

                 'derivepassphrase',

@@ -1486,6 +1503,7 @@ No PEP 508 extras are active.

                         'vault v0.2': False,

                         'vault v0.3': False,

                     },

+                    subcommands=frozenset({'export', 'vault'}),

                     extras=frozenset({}),

                 ),

                 id='derivepassphrase-0.5-plain',

@@ -1506,6 +1524,7 @@ Known derivation schemes: divination, /dev/random,

 Supported foreign configuration formats: derivepassphrase, nonsense.

 Known foreign configuration formats: divination v3.141592,

     /dev/random.

+Supported subcommands: delete-all-files, dump-core.

 PEP 508 extras: annoying-popups, delete-all-files,

     dump-core-depending-on-the-phase-of-the-moon.

@@ -1528,6 +1547,7 @@ PEP 508 extras: annoying-popups, delete-all-files,

                         'divination v3.141592': False,

                         '/dev/random': False,

                     },

+                    subcommands=frozenset({'delete-all-files', 'dump-core'}),

                     extras=frozenset({

                         'annoying-popups',

                         'delete-all-files',

@@ -1778,20 +1798,19 @@ class TestAllCLI:

             'Expected no color, but found an ANSI control sequence'

         )

-    @Parametrize.COMMAND_NON_EAGER_ARGUMENTS

-    def test_202_version_option_output(

+    def test_202a_derivepassphrase_version_option_output(

         self,

-        command: list[str],

-        non_eager_arguments: list[str],

     ) -> None:

         """The version output states supported features.

         The version output is parsed using [`parse_version_output`][].

         Format examples can be found in

-        [`Parametrize.VERSION_OUTPUT_DATA`][].

+        [`Parametrize.VERSION_OUTPUT_DATA`][].  Specifically, for the

+        top-level `derivepassphrase` command, the output should contain

+        the known and supported derivation schemes, and a list of

+        subcommands.

         """

-        del non_eager_arguments

         runner = click.testing.CliRunner(mix_stderr=False)

         # TODO(the-13th-letter): Rewrite using parenthesized

         # with-statements.

@@ -1806,15 +1825,103 @@ class TestAllCLI:

             )

             result_ = runner.invoke(

                 cli.derivepassphrase,

-                [*command, '--version'],

+                ['--version'],

                 catch_exceptions=False,

             )

             result = tests.ReadableResult.parse(result_)

         assert result.clean_exit(empty_stderr=True), 'expected clean exit'

         assert result.output.strip(), 'expected version output'

         version_data = parse_version_output(result.output)

-        actually_known_formats: dict[str, bool] = {}

         actually_known_schemes = {'vault': True}

+        subcommands = {'export', 'vault'}

+        assert version_data.derivation_schemes == actually_known_schemes

+        assert not version_data.foreign_configuration_formats

+        assert version_data.subcommands == subcommands

+        assert not version_data.extras

+

+    def test_202b_export_version_option_output(

+        self,

+    ) -> None:

+        """The version output states supported features.

+

+        The version output is parsed using [`parse_version_output`][].

+        Format examples can be found in

+        [`Parametrize.VERSION_OUTPUT_DATA`][].  Specifically, for the

+        `export` command, the output should contain the known foreign

+        configuration formats (but not marked as supported), and a list

+        of subcommands.

+

+        """

+        runner = click.testing.CliRunner(mix_stderr=False)

+        # TODO(the-13th-letter): Rewrite using parenthesized

+        # with-statements.

+        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

+        with contextlib.ExitStack() as stack:

+            monkeypatch = stack.enter_context(pytest.MonkeyPatch.context())

+            stack.enter_context(

+                tests.isolated_config(

+                    monkeypatch=monkeypatch,

+                    runner=runner,

+                )

+            )

+            result_ = runner.invoke(

+                cli.derivepassphrase,

+                ['export', '--version'],

+                catch_exceptions=False,

+            )

+            result = tests.ReadableResult.parse(result_)

+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'

+        assert result.output.strip(), 'expected version output'

+        version_data = parse_version_output(result.output)

+        actually_known_formats: dict[str, bool] = {

+            'vault storeroom': False,

+            'vault v0.2': False,

+            'vault v0.3': False,

+        }

+        subcommands = {'vault'}

+        assert not version_data.derivation_schemes

+        assert (

+            version_data.foreign_configuration_formats

+            == actually_known_formats

+        )

+        assert version_data.subcommands == subcommands

+        assert not version_data.extras

+

+    def test_202c_export_vault_version_option_output(

+        self,

+    ) -> None:

+        """The version output states supported features.

+

+        The version output is parsed using [`parse_version_output`][].

+        Format examples can be found in

+        [`Parametrize.VERSION_OUTPUT_DATA`][].  Specifically, for the

+        `export vault` subcommand, the output should contain the

+        vault-specific subset of the known or supported foreign

+        configuration formats, and a list of available PEP 508 extras.

+

+        """

+        runner = click.testing.CliRunner(mix_stderr=False)

+        # TODO(the-13th-letter): Rewrite using parenthesized

+        # with-statements.

+        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

+        with contextlib.ExitStack() as stack:

+            monkeypatch = stack.enter_context(pytest.MonkeyPatch.context())

+            stack.enter_context(

+                tests.isolated_config(

+                    monkeypatch=monkeypatch,

+                    runner=runner,

+                )

+            )

+            result_ = runner.invoke(

+                cli.derivepassphrase,

+                ['export', 'vault', '--version'],

+                catch_exceptions=False,

+            )

+            result = tests.ReadableResult.parse(result_)

+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'

+        assert result.output.strip(), 'expected version output'

+        version_data = parse_version_output(result.output)

+        actually_known_formats: dict[str, bool] = {}

         actually_enabled_extras: set[str] = set()

         with contextlib.suppress(ModuleNotFoundError):

             from derivepassphrase.exporter import storeroom, vault_native  # noqa: I001,PLC0415

@@ -1826,13 +1933,52 @@ class TestAllCLI:

             })

             if not storeroom.STUBBED and not vault_native.STUBBED:

                 actually_enabled_extras.add('export')

+        assert not version_data.derivation_schemes

         assert (

             version_data.foreign_configuration_formats

             == actually_known_formats

         )

-        assert version_data.derivation_schemes == actually_known_schemes

+        assert not version_data.subcommands

         assert version_data.extras == actually_enabled_extras

+    def test_202d_vault_version_option_output(

+        self,

+    ) -> None:

+        """The version output states supported features.

+

+        The version output is parsed using [`parse_version_output`][].

+        Format examples can be found in

+        [`Parametrize.VERSION_OUTPUT_DATA`][].  Specifically, for the

+        vault command, the output should not contain anything beyond the

+        first paragraph.

+

+        """

+        runner = click.testing.CliRunner(mix_stderr=False)

+        # TODO(the-13th-letter): Rewrite using parenthesized

+        # with-statements.

+        # https://the13thletter.info/derivepassphrase/latest/pycompatibility/#after-eol-py3.9

+        with contextlib.ExitStack() as stack:

+            monkeypatch = stack.enter_context(pytest.MonkeyPatch.context())

+            stack.enter_context(

+                tests.isolated_config(

+                    monkeypatch=monkeypatch,

+                    runner=runner,

+                )

+            )

+            result_ = runner.invoke(

+                cli.derivepassphrase,

+                ['vault', '--version'],

+                catch_exceptions=False,

+            )

+            result = tests.ReadableResult.parse(result_)

+        assert result.clean_exit(empty_stderr=True), 'expected clean exit'

+        assert result.output.strip(), 'expected version output'

+        version_data = parse_version_output(result.output)

+        assert not version_data.derivation_schemes

+        assert not version_data.foreign_configuration_formats

+        assert not version_data.subcommands

+        assert not version_data.extras

+

 class TestCLI:

     """Tests for the `derivepassphrase vault` command-line interface."""