stove/rougail-output-doc
2
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity

fix: black

Browse source
This commit is contained in:
egarette@silique.fr 2025-10-15 09:44:22 +02:00
parent 6dd6df77a1
commit b4ce22a0af
9 changed files with 341 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
src/rougail/output_doc/changelog.py
View file

@ -39,6 +39,7 @@ class Changelog: # pylint: disable=no-member,too-few-public-methods
def parser(self, previous_families, new_families): def parser(self, previous_families, new_families):
def add(new): def add(new):
self.formater.variable_to_string(new, self._added_variables) self.formater.variable_to_string(new, self._added_variables)
def remove(previous): def remove(previous):
self._removed_variables.append(element) self._removed_variables.append(element)
@ -66,7 +67,7 @@ class Changelog: # pylint: disable=no-member,too-few-public-methods
else: else:
add(new) add(new)
self.parser(previous["children"], {}) self.parser(previous["children"], {})
elif previous["type"] != 'variable': elif previous["type"] != "variable":
self.parser(previous["children"], new["children"]) self.parser(previous["children"], new["children"])
else: else:
modified_attributes = {} modified_attributes = {}
@ -75,14 +76,21 @@ class Changelog: # pylint: disable=no-member,too-few-public-methods
prop_new = new.get(prop, []) prop_new = new.get(prop, [])
if prop_previous != prop_new: if prop_previous != prop_new:
name = None name = None
if isinstance(prop_previous, dict) and "values" in prop_previous: if (
isinstance(prop_previous, dict)
and "values" in prop_previous
):
name = prop_previous["name"] name = prop_previous["name"]
local_prop_previous = prop_previous = prop_previous["values"] local_prop_previous = prop_previous = prop_previous[
"values"
]
if not isinstance(prop_previous, list): if not isinstance(prop_previous, list):
if prop == "default": if prop == "default":
local_prop_previous = [prop_previous] local_prop_previous = [prop_previous]
else: else:
local_prop_previous = prop_previous = [prop_previous] local_prop_previous = prop_previous = [
prop_previous
]
else: else:
local_prop_previous = prop_previous local_prop_previous = prop_previous
if isinstance(prop_new, dict) and "values" in prop_new: if isinstance(prop_new, dict) and "values" in prop_new:
@ -95,36 +103,63 @@ class Changelog: # pylint: disable=no-member,too-few-public-methods
else: else:
prop_new = [prop_new] prop_new = [prop_new]
if isinstance(prop_previous, list): if isinstance(prop_previous, list):
prop_previous = [p for p in prop_previous if p not in prop_new] prop_previous = [
p for p in prop_previous if p not in prop_new
]
elif prop_previous in prop_new: elif prop_previous in prop_new:
prop_new.remove(prop_previous) prop_new.remove(prop_previous)
prop_previous = [] prop_previous = []
prop_new = [p for p in prop_new if p not in local_prop_previous] prop_new = [p for p in prop_new if p not in local_prop_previous]
if prop_previous not in [None, []] or prop_new not in [None, []]: if prop_previous not in [None, []] or prop_new not in [
None,
[],
]:
modified_attributes[prop] = (name, prop_previous, prop_new) modified_attributes[prop] = (name, prop_previous, prop_new)
if not modified_attributes: if not modified_attributes:
continue continue
self.formater.variable_to_string(new, self._modified_variables, modified_attributes) self.formater.variable_to_string(
new, self._modified_variables, modified_attributes
)
def display(self) -> str: def display(self) -> str:
msg = '' msg = ""
if self._added_variables: if self._added_variables:
if len(self._added_variables) == 1: if len(self._added_variables) == 1:
title = _('New variable') title = _("New variable")
else: else:
title = _('New variables') title = _("New variables")
msg += self.formater.run([self.formater.title(title, self.level), self.formater.table(self._added_variables)], self.level, dico_is_already_treated=True) msg += self.formater.run(
[
self.formater.title(title, self.level),
self.formater.table(self._added_variables),
],
self.level,
dico_is_already_treated=True,
)
if self._modified_variables: if self._modified_variables:
if len(self._modified_variables) == 1: if len(self._modified_variables) == 1:
title = _('Modified variable') title = _("Modified variable")
else: else:
title = _('Modified variables') title = _("Modified variables")
msg += self.formater.run([self.formater.title(title, self.level), self.formater.table(self._modified_variables)], self.level, dico_is_already_treated=True) msg += self.formater.run(
[
self.formater.title(title, self.level),
self.formater.table(self._modified_variables),
],
self.level,
dico_is_already_treated=True,
)
if self._removed_variables: if self._removed_variables:
if len(self._removed_variables) == 1: if len(self._removed_variables) == 1:
title = _('Deleted variable') title = _("Deleted variable")
else: else:
title = _('Deleted variables') title = _("Deleted variables")
msg += self.formater.run([self.formater.title(title, self.level), self.formater.list(self._removed_variables)], self.level, dico_is_already_treated=True) msg += self.formater.run(
[
self.formater.title(title, self.level),
self.formater.list(self._removed_variables),
],
self.level,
dico_is_already_treated=True,
)
return msg return msg

82
src/rougail/output_doc/doc.py
View file

@ -91,7 +91,7 @@ class RougailOutputDoc(Examples, Changelog):
else: else:
self.with_family = True self.with_family = True
if "changelog" in self.contents: if "changelog" in self.contents:
self.previous_json_file = rougailconfig['doc.previous_json_file'] self.previous_json_file = rougailconfig["doc.previous_json_file"]
self.formater = outputs[output_format](self.with_family) self.formater = outputs[output_format](self.with_family)
self.informations = None self.informations = None
try: try:
@ -105,7 +105,7 @@ class RougailOutputDoc(Examples, Changelog):
def run(self) -> str: def run(self) -> str:
"""Print documentation in stdout""" """Print documentation in stdout"""
self.load() self.load()
return_string = '' return_string = ""
if "variables" in self.contents: if "variables" in self.contents:
return_string += self.formater.run(self.informations, self.level) return_string += self.formater.run(self.informations, self.level)
if "example" in self.contents: if "example" in self.contents:
@ -144,14 +144,19 @@ class RougailOutputDoc(Examples, Changelog):
new_name = True new_name = True
description = obj.description(uncalculated=True) description = obj.description(uncalculated=True)
name = obj.name(uncalculated=True) name = obj.name(uncalculated=True)
self.dynamic_paths[path] = {"names": [], self.dynamic_paths[path] = {
"names": [],
"identifiers": [], "identifiers": [],
"path": path, "path": path,
} }
if not obj.information.get("forced_description", False): if not obj.information.get("forced_description", False):
self.dynamic_paths[path]["description"] = self._convert_description(description, obj, type_, its_a_path=False) self.dynamic_paths[path]["description"] = self._convert_description(
description, obj, type_, its_a_path=False
)
elif obj.isoptiondescription(): elif obj.isoptiondescription():
self.dynamic_paths[path]["description"] = self._convert_description(description, obj, type_, its_a_path=True) self.dynamic_paths[path]["description"] = self._convert_description(
description, obj, type_, its_a_path=True
)
dynamic_obj = self.dynamic_paths[path] dynamic_obj = self.dynamic_paths[path]
dynamic_obj["names"].append(obj.name()) dynamic_obj["names"].append(obj.name())
dynamic_obj["identifiers"].append(obj.identifiers()) dynamic_obj["identifiers"].append(obj.identifiers())
@ -223,6 +228,7 @@ class RougailOutputDoc(Examples, Changelog):
"informations": family_informations, "informations": family_informations,
"children": sub_informations, "children": sub_informations,
} }
# else: # else:
# informations.update(sub_informations) # informations.update(sub_informations)
@ -319,7 +325,7 @@ class RougailOutputDoc(Examples, Changelog):
informations = self.dynamic_paths[path] informations = self.dynamic_paths[path]
else: else:
informations = {} informations = {}
if not self._populate(family, informations, 'family'): if not self._populate(family, informations, "family"):
return False return False
if family.isleadership(): if family.isleadership():
informations.setdefault("help", []).append( informations.setdefault("help", []).append(
@ -352,7 +358,7 @@ class RougailOutputDoc(Examples, Changelog):
variable, variable,
informations, informations,
) )
if not self._populate(variable, informations, 'variable'): if not self._populate(variable, informations, "variable"):
return False return False
if variable.ismulti(): if variable.ismulti():
multi = not variable.isfollower() or variable.issubmulti() multi = not variable.isfollower() or variable.issubmulti()
@ -389,21 +395,34 @@ class RougailOutputDoc(Examples, Changelog):
return False return False
name = child.name(uncalculated=True) name = child.name(uncalculated=True)
if child.information.get("forced_description", False): if child.information.get("forced_description", False):
if not child.isoptiondescription() or not self.support_namespace or child.group_type() is not groups.namespace: if (
if child.isoptiondescription() or not child.isfollower() or not child.index(): not child.isoptiondescription()
or not self.support_namespace
or child.group_type() is not groups.namespace
):
if (
child.isoptiondescription()
or not child.isfollower()
or not child.index()
):
warning = _('No attribute "description" for "{0}" in {1}').format( warning = _('No attribute "description" for "{0}" in {1}').format(
child.path(uncalculated=True), child.path(uncalculated=True),
display_xmlfiles(child.information.get("ymlfiles")), display_xmlfiles(child.information.get("ymlfiles")),
) )
warn(warning, warn(
warning,
RougailWarning, RougailWarning,
) )
if child.isoptiondescription(): if child.isoptiondescription():
description = self._convert_description(child.description(uncalculated=True), child, type_, its_a_path=True) description = self._convert_description(
child.description(uncalculated=True), child, type_, its_a_path=True
)
else: else:
description = None description = None
else: else:
description = self._convert_description(child.description(uncalculated=True), child, type_, its_a_path=False) description = self._convert_description(
child.description(uncalculated=True), child, type_, its_a_path=False
)
if not child.isdynamic(): if not child.isdynamic():
informations["path"] = child.path(uncalculated=True) informations["path"] = child.path(uncalculated=True)
informations["names"] = [child.name()] informations["names"] = [child.name()]
@ -528,9 +547,7 @@ class RougailOutputDoc(Examples, Changelog):
break break
if child.information.get("type") == "regexp": if child.information.get("type") == "regexp":
validators.append( validators.append(
_('text based with regular expressions "{0}"').format( _('text based with regular expressions "{0}"').format(child.pattern())
child.pattern()
)
) )
if validators: if validators:
if len(validators) == 1: if len(validators) == 1:
@ -675,7 +692,8 @@ class RougailOutputDoc(Examples, Changelog):
child.path(), child.path(),
display_xmlfiles(child.information.get("ymlfiles")), display_xmlfiles(child.information.get("ymlfiles")),
) )
warn(warning, warn(
warning,
RougailWarning, RougailWarning,
) )
return values return values
@ -696,7 +714,12 @@ class RougailOutputDoc(Examples, Changelog):
except VariableCalculationDependencyError: except VariableCalculationDependencyError:
msg = _("depends on an undocumented variable") msg = _("depends on an undocumented variable")
else: else:
if condition == "when" and value == variable_value or condition == "when_not" and value != variable_value: if (
condition == "when"
and value == variable_value
or condition == "when_not"
and value != variable_value
):
if prop in HIDDEN_PROPERTIES: if prop in HIDDEN_PROPERTIES:
return return
# always "{prop}" (but depends on an undocumented variable) # always "{prop}" (but depends on an undocumented variable)
@ -707,12 +730,16 @@ class RougailOutputDoc(Examples, Changelog):
if not calculation["optional"]: if not calculation["optional"]:
msg = _('when the variable "{0}" hasn\'t the value "{1}"') msg = _('when the variable "{0}" hasn\'t the value "{1}"')
else: else:
msg = _('when the variable "{0}" is defined and hasn\'t the value "{1}"') msg = _(
'when the variable "{0}" is defined and hasn\'t the value "{1}"'
)
else: else:
if not calculation["optional"]: if not calculation["optional"]:
msg = _('when the variable "{0}" has the value "{1}"') msg = _('when the variable "{0}" has the value "{1}"')
else: else:
msg = _('when the variable "{0}" is defined and has the value "{1}"') msg = _(
'when the variable "{0}" is defined and has the value "{1}"'
)
if not isinstance(value, str): if not isinstance(value, str):
value = dump(value) value = dump(value)
values = msg.format(variable_path, value) values = msg.format(variable_path, value)
@ -738,9 +765,7 @@ class RougailOutputDoc(Examples, Changelog):
else: else:
regexp = compile( regexp = compile(
"^" "^"
+ calculation["ori_path"].replace( + calculation["ori_path"].replace("{{ identifier }}", "(.*)")
"{{ identifier }}", "(.*)"
)
+ "$" + "$"
) )
informations = [self.dynamic_paths[calculation["value"]]] informations = [self.dynamic_paths[calculation["value"]]]
@ -759,8 +784,12 @@ class RougailOutputDoc(Examples, Changelog):
msg = hidden_msg msg = hidden_msg
else: else:
if "{{ identifier }}" in path: if "{{ identifier }}" in path:
msg = {"message": true_msg, msg = {
"path": {"path": path, "identifiers": identifiers.copy()}, "message": true_msg,
"path": {
"path": path,
"identifiers": identifiers.copy(),
},
} }
else: else:
msg = true_msg.format(path) msg = true_msg.format(path)
@ -786,7 +815,10 @@ class RougailOutputDoc(Examples, Changelog):
uncalculated, Calculation uncalculated, Calculation
): ):
if isinstance(uncalculated, list): if isinstance(uncalculated, list):
true_msg = {"submessage": _("(from an undocumented variable)"), true_msg = {
"submessage": _(
"(from an undocumented variable)"
),
"values": uncalculated, "values": uncalculated,
} }
else: else:

1
src/rougail/output_doc/example.py
View file

@ -118,6 +118,7 @@ class Examples: # pylint: disable=no-member,too-few-public-methods
examples_mandatories[name] = ret_m examples_mandatories[name] = ret_m
if ret_e: if ret_e:
examples[name] = ret_e examples[name] = ret_e
ori_path = family["informations"]["path"] ori_path = family["informations"]["path"]
if "identifiers" in family["informations"]: if "identifiers" in family["informations"]:
for idx, identifiers in enumerate(family["informations"]["identifiers"]): for idx, identifiers in enumerate(family["informations"]["identifiers"]):

6
src/rougail/output_doc/output/github.py
View file

@ -98,9 +98,9 @@ class Formater(CommonFormater):
def table_header(self, lst): def table_header(self, lst):
"""Manage the header of a table""" """Manage the header of a table"""
return lst[0] + " " * (self.max_line_variable - len(lst[0])), lst[1] + " " * ( return lst[0] + " " * (self.max_line_variable - len(lst[0])), lst[
self.max_line_description - len(lst[1]) 1
) ] + " " * (self.max_line_description - len(lst[1]))
def yaml(self, _dump): def yaml(self, _dump):
"""Dump yaml part of documentation""" """Dump yaml part of documentation"""

5
src/rougail/output_doc/output/gitlab.py
View file

@ -36,10 +36,10 @@ class Formater(GithubFormater):
def title(self, title: str, level: int) -> str: def title(self, title: str, level: int) -> str:
# self.max_line_variable = 0 # self.max_line_variable = 0
return '<details><summary>' + title + '</summary>\n\n' return "<details><summary>" + title + "</summary>\n\n"
def end_family(self, level): def end_family(self, level):
return '</details>\n\n' return "</details>\n\n"
def columns( def columns(
self, self,
@ -52,6 +52,7 @@ class Formater(GithubFormater):
def end_family_informations(self) -> str: def end_family_informations(self) -> str:
return f"\n>>>\n" return f"\n>>>\n"
def after_family_paths(self) -> str: def after_family_paths(self) -> str:
return "<br>" return "<br>"

6
src/rougail/output_doc/output/html.py
View file

@ -96,7 +96,11 @@ class Formater(CommonFormater):
"""Display a liste of element""" """Display a liste of element"""
prefix = "<ul>" prefix = "<ul>"
char = "\n" char = "\n"
return "<ul>" + char.join(["<li>" + dump(choice) + "</li>" for choice in choices]) + "</ul>" return (
"<ul>"
+ char.join(["<li>" + dump(choice) + "</li>" for choice in choices])
+ "</ul>"
)
def prop( def prop(
self, self,

236
src/rougail/output_doc/utils.py
View file

@ -127,21 +127,20 @@ def dump(informations):
def to_phrase(msg, type_="variable"): def to_phrase(msg, type_="variable"):
"""Add maj for the first character and ends with dot """Add maj for the first character and ends with dot"""
"""
if not msg: if not msg:
# replace None to empty string # replace None to empty string
return "" return ""
msg = str(msg).strip() msg = str(msg).strip()
# a phrase must ends with a dot # a phrase must ends with a dot
if type_ == 'variable': if type_ == "variable":
if not msg.endswith("."): if not msg.endswith("."):
msg += "." msg += "."
elif type_ == 'family': elif type_ == "family":
if msg.endswith("."): if msg.endswith("."):
msg = msg[:-1] msg = msg[:-1]
else: else:
raise Exception('unknown type') raise Exception("unknown type")
# and start with a maj # and start with a maj
return msg[0].upper() + msg[1:] return msg[0].upper() + msg[1:]
@ -214,10 +213,10 @@ class CommonFormater:
################## ##################
def family_informations(self) -> str: def family_informations(self) -> str:
return '' return ""
def end_family_informations(self) -> str: def end_family_informations(self) -> str:
return '' return ""
def display_paths( def display_paths(
self, self,
@ -228,7 +227,12 @@ class CommonFormater:
path = informations["path"] path = informations["path"]
if "identifiers" in modified_attributes: if "identifiers" in modified_attributes:
name, previous, new = modified_attributes["identifiers"] name, previous, new = modified_attributes["identifiers"]
ret_paths.extend([self.bold(self.delete(calc_path(path, self, identifier))) for identifier in previous]) ret_paths.extend(
[
self.bold(self.delete(calc_path(path, self, identifier)))
for identifier in previous
]
)
else: else:
new = [] new = []
if "identifiers" in informations: if "identifiers" in informations:
@ -254,7 +258,9 @@ class CommonFormater:
"""Manage the header of a table""" """Manage the header of a table"""
return lst return lst
def run(self, informations: dict, level: int, *, dico_is_already_treated=False) -> str: def run(
self, informations: dict, level: int, *, dico_is_already_treated=False
) -> str:
"""Transform to string""" """Transform to string"""
if informations: if informations:
return self._run(informations, level, dico_is_already_treated) return self._run(informations, level, dico_is_already_treated)
@ -266,7 +272,14 @@ class CommonFormater:
return "".join(dico) return "".join(dico)
return "".join([msg for msg in self.dict_to_dict(dico, level, init=True)]) return "".join([msg for msg in self.dict_to_dict(dico, level, init=True)])
def dict_to_dict(self, dico: dict, level: int, *, ori_table_datas: list = None, init: bool = False) -> str: def dict_to_dict(
self,
dico: dict,
level: int,
*,
ori_table_datas: list = None,
init: bool = False,
) -> str:
"""Parse the dict to transform to dict""" """Parse the dict to transform to dict"""
msg = [] msg = []
if ori_table_datas is not None: if ori_table_datas is not None:
@ -288,7 +301,9 @@ class CommonFormater:
msg.append(self.family_informations()) msg.append(self.family_informations())
msg.extend(self.display_paths(informations, {})) msg.extend(self.display_paths(informations, {}))
msg.append(self.after_family_paths()) msg.append(self.after_family_paths())
msg.append(self.property_to_string(informations, {}, {})[1] + ENTER) msg.append(
self.property_to_string(informations, {}, {})[1] + ENTER
)
msg.append(self.end_family_informations()) msg.append(self.end_family_informations())
msg.extend(self.dict_to_dict(value["children"], level)) msg.extend(self.dict_to_dict(value["children"], level))
msg.append(self.end_namespace(ori_level)) msg.append(self.end_namespace(ori_level))
@ -300,7 +315,9 @@ class CommonFormater:
msg.extend(self.dict_to_dict(value["children"], level + 1)) msg.extend(self.dict_to_dict(value["children"], level + 1))
msg.append(self.end_family(level)) msg.append(self.end_family(level))
else: else:
self.dict_to_dict(value["children"], level + 1, ori_table_datas=table_datas) self.dict_to_dict(
value["children"], level + 1, ori_table_datas=table_datas
)
if (init or ori_table_datas is None) and table_datas: if (init or ori_table_datas is None) and table_datas:
msg.append(self.table(table_datas)) msg.append(self.table(table_datas))
return msg return msg
@ -309,7 +326,9 @@ class CommonFormater:
def namespace_to_title(self, informations: dict, level: int) -> str: def namespace_to_title(self, informations: dict, level: int) -> str:
"""manage namespace family""" """manage namespace family"""
return self.title( return self.title(
_('Variables for "{0}"').format(self.get_description("family", informations)), _('Variables for "{0}"').format(
self.get_description("family", informations)
),
level, level,
) )
@ -324,24 +343,31 @@ class CommonFormater:
for help_ in helps: for help_ in helps:
msg.append(self.display_family_help(help_.strip())) msg.append(self.display_family_help(help_.strip()))
msg.append(self.family_informations()) msg.append(self.family_informations())
msg.append(self.join(self.display_paths(informations, {}) msg.append(
) + self.after_family_paths() self.join(self.display_paths(informations, {})) + self.after_family_paths()
) )
calculated_properties = [] calculated_properties = []
msg.append(self.property_to_string(informations, calculated_properties, {})[1] + ENTER) msg.append(
self.property_to_string(informations, calculated_properties, {})[1] + ENTER
)
if calculated_properties: if calculated_properties:
msg.append(self.join(calculated_properties) + self.after_family_properties()) msg.append(
self.join(calculated_properties) + self.after_family_properties()
)
if "identifier" in informations: if "identifier" in informations:
msg.append( msg.append(
self.section(_("Identifiers"), informations["identifier"]) + self.after_family_properties() self.section(_("Identifiers"), informations["identifier"])
+ self.after_family_properties()
) )
msg.append(self.end_family_informations()) msg.append(self.end_family_informations())
return msg return msg
def end_family(self, level: int) -> str: def end_family(self, level: int) -> str:
return '' return ""
def convert_list_to_string(self, attribute: str, informations: dict, modified_attributes: dict) -> str(): def convert_list_to_string(
self, attribute: str, informations: dict, modified_attributes: dict
) -> str():
datas = [] datas = []
if attribute in modified_attributes: if attribute in modified_attributes:
name, previous, new = modified_attributes[attribute] name, previous, new = modified_attributes[attribute]
@ -352,27 +378,37 @@ class CommonFormater:
if attribute in informations: if attribute in informations:
for data in informations[attribute]: for data in informations[attribute]:
if isinstance(data, dict): if isinstance(data, dict):
if attribute.endswith('s'): if attribute.endswith("s"):
attr = attribute[:-1] attr = attribute[:-1]
else: else:
attr = attribute attr = attribute
data = data[attr].replace('{{ identifier }}', self.italic(data["identifier"])) data = data[attr].replace(
"{{ identifier }}", self.italic(data["identifier"])
)
data = self.to_phrase(data) data = self.to_phrase(data)
if data in new: if data in new:
data = self.underline(data) data = self.underline(data)
datas.append(data) datas.append(data)
return self.stripped(self.join(datas)) return self.stripped(self.join(datas))
def get_description(self, type_: str, informations: dict, modified_attributes: dict={}) -> str(): def get_description(
self, type_: str, informations: dict, modified_attributes: dict = {}
) -> str():
def _get_description(description, identifiers, delete=False, new=[]): def _get_description(description, identifiers, delete=False, new=[]):
if "{{ identifier }}" in description: if "{{ identifier }}" in description:
if type_ == "variable": if type_ == "variable":
identifiers_text = display_list([self.italic(i[-1]) for i in identifiers], separator="or") identifiers_text = display_list(
description = description.replace('{{ identifier }}', identifiers_text) [self.italic(i[-1]) for i in identifiers], separator="or"
)
description = description.replace(
"{{ identifier }}", identifiers_text
)
else: else:
d = [] d = []
for i in identifiers: for i in identifiers:
new_description = description.replace('{{ identifier }}', self.italic(i[-1])) new_description = description.replace(
"{{ identifier }}", self.italic(i[-1])
)
if new_description not in d: if new_description not in d:
d.append(self.to_phrase(new_description)) d.append(self.to_phrase(new_description))
description = display_list(d, separator="or") description = display_list(d, separator="or")
@ -383,13 +419,18 @@ class CommonFormater:
if delete: if delete:
description = self.delete(description) description = self.delete(description)
return description return description
if "description" in modified_attributes: if "description" in modified_attributes:
name, previous, new = modified_attributes["description"] name, previous, new = modified_attributes["description"]
modified_description = _get_description(previous, modified_attributes.get("identifiers", []), delete=True) modified_description = _get_description(
previous, modified_attributes.get("identifiers", []), delete=True
)
else: else:
modified_description = None modified_description = None
new = [] new = []
description = _get_description(informations["description"], informations.get("identifiers"), new=new) description = _get_description(
informations["description"], informations.get("identifiers"), new=new
)
if modified_description: if modified_description:
if description: if description:
description = self.join([modified_description, description]) description = self.join([modified_description, description])
@ -399,65 +440,97 @@ class CommonFormater:
return None return None
return self.stripped(description) return self.stripped(description)
# VARIABLE # VARIABLE
def variable_to_string(self, informations: dict, table_datas: list, modified_attributes: dict={}) -> None: def variable_to_string(
self, informations: dict, table_datas: list, modified_attributes: dict = {}
) -> None:
"""Manage variable""" """Manage variable"""
calculated_properties = [] calculated_properties = []
multi, first_column = self.variable_first_column(informations, calculated_properties, modified_attributes) multi, first_column = self.variable_first_column(
informations, calculated_properties, modified_attributes
)
table_datas.append( table_datas.append(
[ [
self.join(first_column), self.join(first_column),
self.join( self.join(
self.variable_second_column(informations, calculated_properties, modified_attributes, multi=multi) self.variable_second_column(
informations,
calculated_properties,
modified_attributes,
multi=multi,
)
), ),
] ]
) )
def variable_first_column( def variable_first_column(
self, informations: dict, calculated_properties: list, modified_attributes: Optional[dict] self,
informations: dict,
calculated_properties: list,
modified_attributes: Optional[dict],
) -> list: ) -> list:
"""Collect string for the first column""" """Collect string for the first column"""
multi, properties = self.property_to_string(informations, calculated_properties, modified_attributes) multi, properties = self.property_to_string(
informations, calculated_properties, modified_attributes
)
first_col = [ first_col = [
self.join( self.join(self.display_paths(informations, modified_attributes)),
self.display_paths(informations, modified_attributes) properties,
), properties
] ]
self.columns(first_col) self.columns(first_col)
return multi, first_col return multi, first_col
def variable_second_column( def variable_second_column(
self, informations: dict, calculated_properties: list, modified_attributes: dict, multi: bool self,
informations: dict,
calculated_properties: list,
modified_attributes: dict,
multi: bool,
) -> list: ) -> list:
"""Collect string for the second column""" """Collect string for the second column"""
second_col = [] second_col = []
# #
if "description" in informations: if "description" in informations:
description = self.get_description("variable", informations, modified_attributes) description = self.get_description(
"variable", informations, modified_attributes
)
second_col.append(description) second_col.append(description)
# #
help_ = self.convert_list_to_string("help", informations, modified_attributes) help_ = self.convert_list_to_string("help", informations, modified_attributes)
if help_: if help_:
second_col.append(help_) second_col.append(help_)
# #
validators = self.convert_section_to_string("validators", informations, modified_attributes, multi=True) validators = self.convert_section_to_string(
"validators", informations, modified_attributes, multi=True
)
if validators: if validators:
second_col.append(validators) second_col.append(validators)
default_is_already_set, choices = self.convert_choices_to_string(informations, modified_attributes) default_is_already_set, choices = self.convert_choices_to_string(
informations, modified_attributes
)
if choices: if choices:
second_col.append(choices) second_col.append(choices)
if not default_is_already_set and "default" in informations: if not default_is_already_set and "default" in informations:
self.convert_section_to_string("default", informations, modified_attributes, multi=multi) self.convert_section_to_string(
second_col.append(self.convert_section_to_string("default", informations, modified_attributes, multi=multi)) "default", informations, modified_attributes, multi=multi
examples = self.convert_section_to_string("examples", informations, modified_attributes, multi=True) )
second_col.append(
self.convert_section_to_string(
"default", informations, modified_attributes, multi=multi
)
)
examples = self.convert_section_to_string(
"examples", informations, modified_attributes, multi=True
)
if examples: if examples:
second_col.append(examples) second_col.append(examples)
second_col.extend(calculated_properties) second_col.extend(calculated_properties)
self.columns(second_col) self.columns(second_col)
return second_col return second_col
def convert_section_to_string(self, attribute: str, informations: dict, modified_attributes: dict, multi: bool) -> str(): def convert_section_to_string(
self, attribute: str, informations: dict, modified_attributes: dict, multi: bool
) -> str():
values = [] values = []
submessage = "" submessage = ""
if modified_attributes and attribute in modified_attributes: if modified_attributes and attribute in modified_attributes:
@ -507,7 +580,9 @@ class CommonFormater:
if values != []: if values != []:
return self.section(name, values, submessage=submessage) return self.section(name, values, submessage=submessage)
def convert_choices_to_string(self, informations: dict, modified_attributes: dict) -> str(): def convert_choices_to_string(
self, informations: dict, modified_attributes: dict
) -> str():
default_is_already_set = False default_is_already_set = False
if "choices" in informations: if "choices" in informations:
choices = informations["choices"] choices = informations["choices"]
@ -524,7 +599,11 @@ class CommonFormater:
if not isinstance(old_default, list): if not isinstance(old_default, list):
old_default = [old_default] old_default = [old_default]
for value in old_default.copy(): for value in old_default.copy():
if isinstance(value, str) and value.endswith(".") and value not in choices_values: if (
isinstance(value, str)
and value.endswith(".")
and value not in choices_values
):
old_default.remove(value) old_default.remove(value)
old_default.append(value[:-1]) old_default.append(value[:-1])
else: else:
@ -540,7 +619,11 @@ class CommonFormater:
if default_value_not_in_choices: if default_value_not_in_choices:
default_is_changed = False default_is_changed = False
for val in default_value_not_in_choices.copy(): for val in default_value_not_in_choices.copy():
if isinstance(val, str) and val.endswith('.') and val[:-1] in choices_values: if (
isinstance(val, str)
and val.endswith(".")
and val[:-1] in choices_values
):
default.remove(val) default.remove(val)
default.append(val[:-1]) default.append(val[:-1])
default_is_changed = True default_is_changed = True
@ -559,22 +642,34 @@ class CommonFormater:
name, previous, new = modified_attributes["choices"] name, previous, new = modified_attributes["choices"]
for choice in reversed(previous): for choice in reversed(previous):
if choice in old_default: if choice in old_default:
choices_values.insert(0, self.delete(dump(choice) + " ← " + _("(default)"))) choices_values.insert(
0, self.delete(dump(choice) + " ← " + _("(default)"))
)
else: else:
choices_values.insert(0, self.delete(dump(choice))) choices_values.insert(0, self.delete(dump(choice)))
else: else:
new = [] new = []
for idx, val in enumerate(choices_values): for idx, val in enumerate(choices_values):
if val in old_default: if val in old_default:
choices_values[idx] = dump(val) + " " + self.delete("← " + _("(default)")) choices_values[idx] = (
dump(val) + " " + self.delete("← " + _("(default)"))
)
elif val in default: elif val in default:
if val in new_default: if val in new_default:
if val in new: if val in new:
choices_values[idx] = self.underline(dump(val) + " " + self.bold("← " + _("(default)"))) choices_values[idx] = self.underline(
dump(val) + " " + self.bold("← " + _("(default)"))
)
else: else:
choices_values[idx] = dump(val) + " " + self.underline(self.bold("← " + _("(default)"))) choices_values[idx] = (
dump(val)
+ " "
+ self.underline(self.bold("← " + _("(default)")))
)
else: else:
choices_values[idx] = dump(val) + " " + self.bold("← " + _("(default)")) choices_values[idx] = (
dump(val) + " " + self.bold("← " + _("(default)"))
)
elif val in new: elif val in new:
choices_values[idx] = self.underline(dump(val)) choices_values[idx] = self.underline(dump(val))
# if old value and new value is a list, display a list # if old value and new value is a list, display a list
@ -591,14 +686,19 @@ class CommonFormater:
return self.to_phrase(help_) + ENTER return self.to_phrase(help_) + ENTER
def property_to_string( def property_to_string(
self, informations: dict, calculated_properties: list, modified_attributes: dict, self,
informations: dict,
calculated_properties: list,
modified_attributes: dict,
) -> str: ) -> str:
"""Transform properties to string""" """Transform properties to string"""
properties = [] properties = []
local_calculated_properties = {} local_calculated_properties = {}
multi = False multi = False
if "properties" in modified_attributes: if "properties" in modified_attributes:
previous, new = self.get_modified_properties(*modified_attributes["properties"][1:]) previous, new = self.get_modified_properties(
*modified_attributes["properties"][1:]
)
for p, annotation in previous.items(): for p, annotation in previous.items():
if p not in new: if p not in new:
properties.append(self.prop(self.delete(p), italic=False)) properties.append(self.prop(self.delete(p), italic=False))
@ -617,30 +717,43 @@ class CommonFormater:
if "annotation" in prop: if "annotation" in prop:
italic = True italic = True
prop_annotation = prop["annotation"] prop_annotation = prop["annotation"]
if prop_name in new and (prop_name not in previous or new[prop_name] != previous[prop_name]): if prop_name in new and (
prop_name not in previous
or new[prop_name] != previous[prop_name]
):
prop_annotation = self.underline(prop_annotation) prop_annotation = self.underline(prop_annotation)
local_calculated_properties.setdefault(prop["name"], []).append(prop_annotation) local_calculated_properties.setdefault(prop["name"], []).append(
prop_annotation
)
else: else:
italic = False italic = False
if prop_name not in previous and prop_name in new: if prop_name not in previous and prop_name in new:
prop_name = self.underline(prop_name) prop_name = self.underline(prop_name)
properties.append(self.prop(prop_name, italic=italic)) properties.append(self.prop(prop_name, italic=italic))
if local_calculated_properties: if local_calculated_properties:
for calculated_property_name, calculated_property in local_calculated_properties.items(): for (
calculated_property_name,
calculated_property,
) in local_calculated_properties.items():
if len(calculated_property) > 1: if len(calculated_property) > 1:
calculated_property = self.join(calculated_property) calculated_property = self.join(calculated_property)
else: else:
calculated_property = calculated_property[0] calculated_property = calculated_property[0]
calculated_properties.append( calculated_properties.append(
self.section(calculated_property_name.capitalize(), calculated_property) self.section(
calculated_property_name.capitalize(), calculated_property
)
) )
if not properties: if not properties:
return multi, "" return multi, ""
return multi, " ".join(properties) return multi, " ".join(properties)
def get_modified_properties(self, previous: List[dict], new: List[dict]) -> Tuple[dict, dict]: def get_modified_properties(
self, previous: List[dict], new: List[dict]
) -> Tuple[dict, dict]:
def modified_properties_parser(dico): def modified_properties_parser(dico):
return {d["name"]: d.get("annotation") for d in dico} return {d["name"]: d.get("annotation") for d in dico}
return modified_properties_parser(previous), modified_properties_parser(new) return modified_properties_parser(previous), modified_properties_parser(new)
def columns( def columns(
@ -707,7 +820,8 @@ def calc_path(path, formater=None, identifiers: List[str]=None) -> str:
identifier = normalize_family(str(identifier)) identifier = normalize_family(str(identifier))
if formater: if formater:
identifier = formater.italic(identifier) identifier = formater.italic(identifier)
return path.replace('{{ identifier }}', identifier, 1) return path.replace("{{ identifier }}", identifier, 1)
if isinstance(path, dict): if isinstance(path, dict):
path_ = path["path"] path_ = path["path"]
for identifier in path["identifiers"]: for identifier in path["identifiers"]: