rougail/src/rougail/annotator/group.py

"""Annotate group
"""
from typing import List

from ..i18n import _
from ..error import DictConsistencyError


class GroupAnnotator:
    """Annotate group
    """
    def __init__(self,
                 objectspace,
                 ):
        self.objectspace = objectspace
        if not hasattr(self.objectspace.space, 'constraints') or \
                not hasattr(self.objectspace.space.constraints, 'group'):
            return
        self.convert_groups()

    def convert_groups(self):  # pylint: disable=C0111
        """convert groups
        """
        for group in self.objectspace.space.constraints.group:
            leader_fullname = group.leader
            leader_family_name = self.objectspace.paths.get_variable_family_name(leader_fullname)
            leader_name = self.objectspace.paths.get_variable_name(leader_fullname)
            namespace = self.objectspace.paths.get_variable_namespace(leader_fullname)
            if '.' not in leader_fullname:
                leader_fullname = '.'.join([namespace, leader_family_name, leader_fullname])
            follower_names = list(group.follower.keys())
            has_a_leader = False
            leader_family = leader_fullname.rsplit('.', 1)[0]
            ori_leader_family = self.objectspace.paths.get_family_obj(leader_family)
            for variable in list(ori_leader_family.variable.values()):
                if has_a_leader:
                    # it's a follower
                    self.manage_follower(leader_family_name,
                                         variable,
                                         leadership_name,
                                         follower_names,
                                         )
                    if leader_is_hidden:
                        variable.frozen = True
                        variable.force_default_on_freeze = True
                    leader_space.variable.append(variable)
                    ori_leader_family.variable.pop(variable.name)
                    if follower_names == []:
                        # no more follower
                        break
                elif variable.name == leader_name:
                    # it's a leader
                    if isinstance(variable, self.objectspace.leadership):
                        # append follower to an existed leadership
                        leader_space = variable
                        # if variable.hidden:
                        #     leader_is_hidden = True
                    else:
                        leader_space = self.objectspace.leadership(variable.xmlfiles)
                        if hasattr(group, 'name'):
                            leadership_name = group.name
                        else:
                            leadership_name = leader_name
                        leader_is_hidden = self.manage_leader(leader_space,
                                                              leader_family_name,
                                                              leadership_name,
                                                              leader_name,
                                                              variable,
                                                              group,
                                                              leader_fullname,
                                                              )
                    has_a_leader = True
            else:
                xmlfiles = self.objectspace.display_xmlfiles(variable.xmlfiles)
                joined = '", "'.join(follower_names)
                msg = _(f'when parsing leadership, we espect to find those followers "{joined}" '
                        f'in {xmlfiles}')
                raise DictConsistencyError(msg, 31)
        del self.objectspace.space.constraints.group

    def manage_leader(self,
                      leader_space: 'Leadership',
                      leader_family_name: str,
                      leadership_name: str,
                      leader_name: str,
                      variable: 'Variable',
                      group: 'Group',
                      leader_fullname: str,
                      ) -> None:
        """manage leader's variable
        """
        if variable.multi is not True:
            xmlfiles = self.objectspace.display_xmlfiles(variable.xmlfiles)
            msg = _(f'the variable "{variable.name}" in a group must be multi in {xmlfiles}')
            raise DictConsistencyError(msg, 32)
        leader_space.variable = []
        leader_space.name = leadership_name
        leader_space.hidden = variable.hidden
        if variable.hidden:
            leader_is_hidden = True
            variable.frozen = True
            variable.force_default_on_freeze = True
        else:
            leader_is_hidden = False
        variable.hidden = None
        if hasattr(group, 'description'):
            leader_space.doc = group.description
        elif hasattr(variable, 'description'):
            leader_space.doc = variable.description
        else:
            leader_space.doc = variable.name
        namespace = variable.namespace
        leadership_path = namespace + '.' + leader_family_name + '.' + leadership_name
        self.objectspace.paths.add_family(namespace,
                                          leadership_path,
                                          leader_space,
                                          )
        leader_family = self.objectspace.space.variables[namespace].family[leader_family_name]
        leader_family.variable[leader_name] = leader_space
        leader_space.variable.append(variable)
        self.objectspace.paths.set_leader(namespace,
                                          leader_family_name,
                                          leader_name,
                                          leader_name,
                                          )
        leader_space.path = leader_fullname
        return leader_is_hidden

    def manage_follower(self,
                        leader_family_name: str,
                        variable: 'Variable',
                        leader_name: str,
                        follower_names: List[str],
                        ) -> None:
        """manage follower
        """
        follower_name = follower_names.pop(0)
        if variable.name != follower_name:
            xmlfiles = self.objectspace.display_xmlfiles(variable.xmlfiles)
            msg = _('when parsing leadership, we espect to find the follower '
                    f'"{follower_name}" but we found "{variable.name}" in {xmlfiles}')
            raise DictConsistencyError(msg, 33)
        self.objectspace.paths.set_leader(variable.namespace,
                                          leader_family_name,
                                          variable.name,
                                          leader_name,
                                          )