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,88 +48,108 @@ 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(
-    parser = TiramisuCmdlineParser(
+        RougailUserDataCommandline(cmd_config,
-        cmd_config,
+            rougailconfig=fake_rougail_config,
-        #        add_extra_options=False,
             short_name_max_len=2,
+            arguments=arguments,
+        ).run()
     )
-    parser.parse_args(arguments)
+    user_data = UserDatas(cmd_config).user_datas(cmd_user_datas)
-    if user_datas:
-        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)
+    # replays to display errors if needed
+    parser = TiramisuCmdlineParser(
+        cmd_config,
+        short_name_max_len=2,
+    )
+    if not cmd_config.option("cli.versions").value.get():
+        parser.parse_args(arguments)
         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
-        filterwarnings("ignore", category=DeprecationWarning)
+
-        filterwarnings("ignore", category=RougailWarning)
+
-    else:
+def display_version(cmd_config):
-        filterwarnings("default", category=DeprecationWarning)
-        filterwarnings("default", category=RougailWarning)
-    if rougailconfig["cli.versions"]:
     versions = []
     from tiramisu import __version__
+    yield(f"tiramisu: {__version__}")
 
-        versions.append(f"tiramisu: {__version__}")
     from tiramisu_cmdline_parser import __version__
+    yield(f"tiramisu-cmdline-parser: {__version__}")
 
-        versions.append(f"tiramisu-cmdline-parser: {__version__}")
     from rougail import __version__
+    yield(f"rougail: {__version__}")
 
-        versions.append(f"rougail: {__version__}")
     from . import __version__
+    yield(f"rougail-cli: {__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()):
@@ -141,16 +163,22 @@ def _main(arguments, do_not_print):
                     module = load_modules(
                         "rougail." + step + "_" + step_name, str(path)
                     )
-                        versions.append(
+                    yield(
                         f"rougail-{display_step}-{step_name}: {module.__version__}"
                     )
                 except Exception as err:
                     pass
-        if do_not_print:
+
-            return versions
+
-        for version in versions:
+def manage_warnings(warnings):
-            print(version)
+    if not warnings:
-        return
+        filterwarnings("ignore", category=DeprecationWarning)
+        filterwarnings("ignore", category=RougailWarning)
+    else:
+        filterwarnings("default", category=DeprecationWarning)
+        filterwarnings("default", category=RougailWarning)
+
+def load_user_datas(rougailconfig):
     try:
         user_data_names = rougailconfig["step.user_data"]
     except PropertiesOptionError:
@@ -163,9 +191,6 @@ def _main(arguments, do_not_print):
     else:
         config = None
     # data user
-    if not user_data_names:
-        user_datas = None
-    else:
     user_datas = []
     for user_data_name in user_data_names:
         path = (
@@ -188,6 +213,10 @@ def _main(arguments, do_not_print):
         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):