187 lines
6 KiB
Python
187 lines
6 KiB
Python
"""
|
|
Silique (https://www.silique.fr)
|
|
Copyright (C) 2022-2025
|
|
|
|
This program is free software: you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by the
|
|
Free Software Foundation, either version 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
This program 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 Lesser General Public License for more
|
|
details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
from typing import Any, List, Optional
|
|
|
|
from json import dumps
|
|
|
|
from tiramisu.error import PropertiesOptionError, ConfigError
|
|
from rougail.error import ExtentionError
|
|
|
|
from .i18n import _
|
|
from .__version__ import __version__
|
|
|
|
|
|
class RougailOutputJson:
|
|
output_name = "json"
|
|
|
|
def __init__(
|
|
self,
|
|
config: "Config",
|
|
*,
|
|
rougailconfig: "RougailConfig" = None,
|
|
user_data_errors: Optional[list] = None,
|
|
user_data_warnings: Optional[list] = None,
|
|
) -> None:
|
|
if rougailconfig is None:
|
|
from rougail import RougailConfig
|
|
|
|
rougailconfig = RougailConfig
|
|
rougailconfig["step.output"] = self.output_name
|
|
if rougailconfig["step.output"] != self.output_name:
|
|
raise ExtentionError(
|
|
_('the "step.output" is not set to "{0}"').format(self.output_name)
|
|
)
|
|
self.rougailconfig = rougailconfig
|
|
self.config = config
|
|
if user_data_errors:
|
|
self.errors = user_data_errors
|
|
else:
|
|
self.errors = []
|
|
if user_data_warnings:
|
|
self.warnings = user_data_warnings
|
|
else:
|
|
self.warnings = []
|
|
self.read_write = self.rougailconfig["json.read_write"]
|
|
self.is_mandatory = self.rougailconfig["json.mandatory"]
|
|
self.get = self.rougailconfig["json.get"]
|
|
self.dico = {}
|
|
|
|
def run(self) -> None:
|
|
ret = self.exporter()
|
|
if isinstance(self.dico, str):
|
|
value = self.dico
|
|
else:
|
|
value = dumps(self.dico, ensure_ascii=False, indent=2)
|
|
return ret, value
|
|
|
|
def print(self) -> str:
|
|
ret, data = self.run()
|
|
print(data)
|
|
return ret
|
|
|
|
def exporter(self) -> None:
|
|
self.config.property.read_write()
|
|
self.mandatory()
|
|
self.config.property.read_only()
|
|
if self.manage_errors():
|
|
return False
|
|
self.manage_warnings()
|
|
if self.read_write:
|
|
self.config.property.read_write()
|
|
if self.get:
|
|
config = self.config.option(self.get)
|
|
if not config.isoptiondescription():
|
|
self.dico = config.value.get()
|
|
return True
|
|
else:
|
|
config = self.config
|
|
self.parse_family(
|
|
config,
|
|
self.dico,
|
|
)
|
|
return True
|
|
|
|
def mandatory(self):
|
|
if not self.is_mandatory:
|
|
return
|
|
title = False
|
|
options_with_error = []
|
|
try:
|
|
mandatories = self.config.value.mandatory()
|
|
except (ConfigError, PropertiesOptionError) as err:
|
|
self.errors.append(_("Error in config: {0}").format(err))
|
|
return
|
|
except ValueError as err:
|
|
self.errors.append(str(err))
|
|
return
|
|
for option in mandatories:
|
|
try:
|
|
option.value.get()
|
|
if not title:
|
|
# self.errors.append("Les variables suivantes sont obligatoires mais n'ont pas de valeur :")
|
|
self.errors.append(
|
|
_("The following variables are mandatory but have no value:")
|
|
)
|
|
title = True
|
|
self.errors.append(f" - {option.description()}")
|
|
except PropertiesOptionError:
|
|
options_with_error.append(option)
|
|
if not title:
|
|
for idx, option in enumerate(options_with_error):
|
|
if not idx:
|
|
# self.errors.append("Les variables suivantes sont inaccessibles mais sont vides et obligatoires :")
|
|
self.errors.append(
|
|
_(
|
|
"The following variables are inaccessible but are empty and mandatory :"
|
|
)
|
|
)
|
|
self.errors.append(f" - {option.description()}")
|
|
|
|
def manage_warnings(self) -> None:
|
|
if self.warnings:
|
|
self.dico["_warnings"] = self.warnings
|
|
|
|
def manage_errors(self) -> bool:
|
|
if not self.errors:
|
|
return False
|
|
self.dico = {"_errors": self.errors}
|
|
self.manage_warnings()
|
|
return True
|
|
|
|
def parse_family(
|
|
self,
|
|
conf,
|
|
child,
|
|
):
|
|
for option in conf:
|
|
if option.isoptiondescription():
|
|
if option.isleadership():
|
|
parent = []
|
|
self.parse_leadership(
|
|
option,
|
|
parent,
|
|
)
|
|
else:
|
|
parent = {}
|
|
self.parse_family(option, parent)
|
|
child[option.name()] = parent
|
|
else:
|
|
child[option.name()] = option.value.get()
|
|
|
|
def parse_leadership(
|
|
self,
|
|
conf,
|
|
parent,
|
|
):
|
|
leader, *followers = list(conf)
|
|
leader_values = leader.value.get()
|
|
for idx, leader_value in enumerate(leader_values):
|
|
leader_dict = {leader.name(): leader_value}
|
|
parent.append(leader_dict)
|
|
for follower in list(followers):
|
|
if follower.index() != idx:
|
|
continue
|
|
followers.remove(follower)
|
|
leader_dict[follower.name()] = follower.value.get()
|
|
|
|
|
|
RougailOutput = RougailOutputJson
|
|
|
|
|
|
__all__ = ("RougailOutputJson",)
|