feat: use rougail-user-data-commandline and mix config use data

pyproject.toml

@@ -13,9 +13,6 @@ license = {file = "LICENSE"}
 classifiers = [
     "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -28,7 +25,7 @@ classifiers = [
 ]
 dependencies = [
     "rougail >= 1.1,<2",
-    "tiramisu_cmdline_parser >= 0.6,<1",
+    "rougail-user-data-commandline",
 ]
 
 [project.scripts]

src/rougail/cli/__main__.py

@@ -20,6 +20,7 @@ import os
 from warnings import warn, filterwarnings
 from pathlib import Path
 from sys import exit
+from argparse import ArgumentError
 
 from tiramisu_cmdline_parser import TiramisuCmdlineParser
 from tiramisu.error import PropertiesOptionError
@@ -31,6 +32,7 @@ from rougail.utils import load_modules
 from rougail.user_datas import UserDatas
 from rougail.error import RougailWarning
 
+from rougail.user_data_commandline import RougailUserDataCommandline
 try:
     from rougail.user_data_yaml import RougailUserDataYaml
 except ImportError:
@@ -46,111 +48,137 @@ from .i18n import _
 ENV_PREFIX = "ROUGAILCLI"
 
 
-
 def _main(arguments, do_not_print):
+    global print_traceback
     rougailconfig = get_rougail_config(
         backward_compatibility=False, add_extra_options=False
     )
     rougailconfig.generate_config()
-    cmd_config = rougailconfig.config
+    cmd_config = load_cmd_user_datas(rougailconfig.config, arguments)
+    print_traceback = rougailconfig["cli.debug"]
+    if rougailconfig["cli.versions"]:
+        versions = display_version(cmd_config)
+        if do_not_print:
+            return list(versions)
+        for version in versions:
+            print(version)
+    else:
+        manage_warnings(rougailconfig["cli.warnings"])
+        config, err_warn = load_user_datas(rougailconfig)
+        output = get_output(rougailconfig, config, err_warn)
+        if do_not_print:
+            return output.run()
+        ret = output.print()
+        if ret is False:
+            exit(1)
+
+
+def load_cmd_user_datas(cmd_config, arguments):
     origin_prop = cmd_config.property.default("read_write", "append")
     cmd_config.property.setdefault(
         frozenset(origin_prop | {"not_for_commandline"}), "read_write", "append"
     )
     cmd_config.property.read_write()
-    fake_rougail_config = {
+    cmd_user_datas = []
-        "step.user_data": [],
-    }
-    fake_user_datas = []
     if RougailUserDataYaml:
-        cli_config_file_key = f"{ENV_PREFIX}_CLI.CONFIG_FILE"
+        config_file = os.environ.pop(f"{ENV_PREFIX}_CLI.CONFIG_FILE", None)
-        config_file = os.environ.pop(cli_config_file_key, None)
         if not config_file:
             config_file = cmd_config.forcepermissive.option("cli.config_file").value.get()
         if Path(config_file).is_file():
             fake_rougail_config = {
-                "step.user_data": "yaml",
+                "step.user_data": ["yaml"],
                 "yaml.filename": [config_file],
                 "yaml.file_with_secrets": "all",
             }
-            fake_user_datas.extend(
+            cmd_user_datas.extend(
-                RougailUserDataYaml(cmd_config, rougailconfig=fake_rougail_config).run()
+                RougailUserDataYaml(cmd_config,
+                                    rougailconfig=fake_rougail_config,
+                                    ).run()
             )
     if RougailUserDataEnvironment:
         fake_rougail_config = {
-            "step.user_data": "environment",
+            "step.user_data": ["environment"],
             "environment.default_environment_name": ENV_PREFIX,
         }
-        fake_user_datas.extend(
+        cmd_user_datas.extend(
             RougailUserDataEnvironment(
-                cmd_config, rougailconfig=fake_rougail_config
+                cmd_config,
+                rougailconfig=fake_rougail_config,
             ).run()
         )
-    if fake_user_datas:
+    fake_rougail_config = {
-        user_datas = UserDatas(cmd_config).user_datas(fake_user_datas, return_values_not_error=True)
+        "step.user_data": ["commandline"],
-    else:
+    }
-        user_datas = {}
+    cmd_user_datas.extend(
+        RougailUserDataCommandline(cmd_config,
+            rougailconfig=fake_rougail_config,
+            short_name_max_len=2,
+            arguments=arguments,
+        ).run()
+    )
+    user_data = UserDatas(cmd_config).user_datas(cmd_user_datas)
+    if user_data["warnings"] and cmd_config.option("cli.warnings").value.get():
+        for warning in user_data["warnings"]:
+            warn(warning)
+    # replays to display errors if needed
     parser = TiramisuCmdlineParser(
         cmd_config,
-        #        add_extra_options=False,
         short_name_max_len=2,
     )
-    parser.parse_args(arguments)
+    if not cmd_config.option("cli.versions").value.get():
-    if user_datas:
+        parser.parse_args(arguments)
-        user_data = UserDatas(cmd_config).user_datas(user_datas, user_datas_type="values", only_default=True)
-        if user_data["warnings"] and cmd_config.option("cli.warnings").value.get():
-            for warning in user_data["warnings"]:
-                warn(warning)
         if user_data["errors"]:
             raise Exception(user_data["errors"][0])
-    global print_traceback
+
-    print_traceback = rougailconfig["cli.debug"]
     cmd_config.property.setdefault(origin_prop, "read_write", "append")
     cmd_config.property.remove("not_for_commandline")
     cmd_config.property.read_only()
-    if not cmd_config.option("cli.warnings").value.get():
+    return cmd_config
+
+
+def display_version(cmd_config):
+    versions = []
+    from tiramisu import __version__
+    yield(f"tiramisu: {__version__}")
+
+    from tiramisu_cmdline_parser import __version__
+    yield(f"tiramisu-cmdline-parser: {__version__}")
+
+    from rougail import __version__
+    yield(f"rougail: {__version__}")
+
+    from . import __version__
+    yield(f"rougail-cli: {__version__}")
+
+    for step in ["structural", "user_data", "output"]:
+        display_step = step.replace("_", "-")
+        for step_name in sorted(cmd_config.unrestraint.option(f"step.{step}").value.list()):
+            path = (
+                Path(__file__).parent.parent
+                / (step + "_" + step_name)
+                / "__init__.py"
+            )
+            if path.is_file():
+                try:
+                    module = load_modules(
+                        "rougail." + step + "_" + step_name, str(path)
+                    )
+                    yield(
+                        f"rougail-{display_step}-{step_name}: {module.__version__}"
+                    )
+                except Exception as err:
+                    pass
+
+
+def manage_warnings(warnings):
+    if not warnings:
         filterwarnings("ignore", category=DeprecationWarning)
         filterwarnings("ignore", category=RougailWarning)
     else:
         filterwarnings("default", category=DeprecationWarning)
         filterwarnings("default", category=RougailWarning)
-    if rougailconfig["cli.versions"]:
-        versions = []
-        from tiramisu import __version__
 
-        versions.append(f"tiramisu: {__version__}")
+def load_user_datas(rougailconfig):
-        from tiramisu_cmdline_parser import __version__
-
-        versions.append(f"tiramisu-cmdline-parser: {__version__}")
-        from rougail import __version__
-
-        versions.append(f"rougail: {__version__}")
-        from . import __version__
-
-        versions.append(f"rougail-cli: {__version__}")
-        for step in ["structural", "user_data", "output"]:
-            display_step = step.replace("_", "-")
-            for step_name in sorted(cmd_config.unrestraint.option(f"step.{step}").value.list()):
-                path = (
-                    Path(__file__).parent.parent
-                    / (step + "_" + step_name)
-                    / "__init__.py"
-                )
-                if path.is_file():
-                    try:
-                        module = load_modules(
-                            "rougail." + step + "_" + step_name, str(path)
-                        )
-                        versions.append(
-                            f"rougail-{display_step}-{step_name}: {module.__version__}"
-                        )
-                    except Exception as err:
-                        pass
-        if do_not_print:
-            return versions
-        for version in versions:
-            print(version)
-        return
     try:
         user_data_names = rougailconfig["step.user_data"]
     except PropertiesOptionError:
@@ -163,31 +191,32 @@ def _main(arguments, do_not_print):
     else:
         config = None
     # data user
-    if not user_data_names:
+    user_datas = []
-        user_datas = None
+    for user_data_name in user_data_names:
-    else:
+        path = (
-        user_datas = []
+            Path(__file__).parent.parent
-        for user_data_name in user_data_names:
+            / ("user_data_" + user_data_name)
-            path = (
+            / "__init__.py"
-                Path(__file__).parent.parent
+        )
-                / ("user_data_" + user_data_name)
+        if not path.is_file():
-                / "__init__.py"
+            raise Exception(
-            )
+                _('cannot find "user_data" module "{0}"').format(user_data_name)
-            if not path.is_file():
-                raise Exception(
-                    _('cannot find "user_data" module "{0}"').format(user_data_name)
-                )
-            module = load_modules("rougail.user_data_" + user_data_name, str(path))
-            user_datas.extend(
-                module.RougailUserData(
-                    config,
-                    rougailconfig=rougailconfig,
-                ).run()
             )
+        module = load_modules("rougail.user_data_" + user_data_name, str(path))
+        user_datas.extend(
+            module.RougailUserData(
+                config,
+                rougailconfig=rougailconfig,
+            ).run()
+        )
     if user_datas:
         err_warn = rougail.user_datas(user_datas)
     else:
         err_warn = {"errors": [], "warnings": []}
+    return config, err_warn
+
+
+def get_output(rougailconfig, config, err_warn):
     # output
     if config and (not rougailconfig["cli.load_config"] or not rougailconfig["cli.read_write"]):
         config.property.read_only()
@@ -204,11 +233,7 @@ def _main(arguments, do_not_print):
         user_data_errors=err_warn["errors"],
         user_data_warnings=err_warn["warnings"],
     )
-    if do_not_print:
+    return output
-        return output.run()
-    ret = output.print()
-    if ret is False:
-        exit(1)
 
 
 def main(arguments=None, do_not_print=False):