rougail-cli/src/rougail/cli/__main__.py

"""
Silique (https://www.silique.fr)
Copyright (C) 2024-2025

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Mtools is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Mtools.  If not, see <http://www.gnu.org/licenses/>.
"""

import os
from warnings import warn, filterwarnings
from pathlib import Path
from sys import exit

from tiramisu_cmdline_parser import TiramisuCmdlineParser
from tiramisu.error import PropertiesOptionError
from tiramisu import Config

from rougail import Rougail
from rougail.config import get_rougail_config
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:
    RougailUserDataYaml = None
try:
    from rougail.user_data_environment import RougailUserDataEnvironment
except ImportError:
    RougailUserDataEnvironment = None

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 = 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()
    cmd_user_datas = []
    if RougailUserDataYaml:
        config_file = os.environ.pop(f"{ENV_PREFIX}_CLI.CONFIG_FILE", 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"],
                "yaml.filename": [config_file],
                "yaml.file_with_secrets": "all",
            }
            cmd_user_datas.extend(
                RougailUserDataYaml(cmd_config,
                                    rougailconfig=fake_rougail_config,
                                    ).run()
            )
    if RougailUserDataEnvironment:
        fake_rougail_config = {
            "step.user_data": ["environment"],
            "environment.default_environment_name": ENV_PREFIX,
        }
        cmd_user_datas.extend(
            RougailUserDataEnvironment(
                cmd_config,
                rougailconfig=fake_rougail_config,
            ).run()
        )
    fake_rougail_config = {
        "step.user_data": ["commandline"],
    }
    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,
        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])

    cmd_config.property.setdefault(origin_prop, "read_write", "append")
    cmd_config.property.remove("not_for_commandline")
    cmd_config.property.read_only()
    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)

def load_user_datas(rougailconfig):
    try:
        user_data_names = rougailconfig["step.user_data"]
    except PropertiesOptionError:
        user_data_names = []
    # structural
    if rougailconfig["cli.load_config"]:
        rougail = Rougail(rougailconfig)
        config = rougail.run()
        config.property.read_write()
    else:
        config = None
    # data user
    user_datas = []
    for user_data_name in user_data_names:
        path = (
            Path(__file__).parent.parent
            / ("user_data_" + user_data_name)
            / "__init__.py"
        )
        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()
        )
    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()
    output_name = rougailconfig["step.output"]
    path = Path(__file__).parent.parent / ("output_" + output_name) / "__init__.py"
    if not path.is_file():
        raise Exception(
            _('cannot find cli file for "output_name" module "{0}"').format(output_name)
        )
    module = load_modules("rougail.output_" + output_name, str(path))
    output = module.RougailOutput(
        config=config,
        rougailconfig=rougailconfig,
        user_data_errors=err_warn["errors"],
        user_data_warnings=err_warn["warnings"],
    )
    return output


def main(arguments=None, do_not_print=False):
    global print_traceback
    print_traceback = True
    try:
        return _main(arguments, do_not_print)
    except Exception as err:
        if print_traceback:
            import traceback

            traceback.print_exc()
        exit(_("ERROR: {0}").format(err))