161 lines
7.0 KiB
Python
161 lines
7.0 KiB
Python
"""Annotate group
|
|
|
|
Created by:
|
|
EOLE (http://eole.orion.education.fr)
|
|
Copyright (C) 2005-2018
|
|
|
|
Forked by:
|
|
Cadoles (http://www.cadoles.com)
|
|
Copyright (C) 2019-2021
|
|
|
|
distribued with GPL-2 or later license
|
|
|
|
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 2 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
"""
|
|
from ..i18n import _
|
|
from ..error import DictConsistencyError
|
|
from ..utils import normalize_family
|
|
|
|
|
|
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
|
|
"""
|
|
# store old leaders family name
|
|
cache_paths = {}
|
|
for group in self.objectspace.space.constraints.group:
|
|
if group.leader in cache_paths:
|
|
leader_fam_path = cache_paths[group.leader]
|
|
else:
|
|
leader_fam_path = self.objectspace.paths.get_variable_family_path(group.leader)
|
|
cache_paths[group.leader] = leader_fam_path
|
|
follower_names = list(group.follower.keys())
|
|
leader = self.objectspace.paths.get_variable(group.leader)
|
|
if '.' not in leader_fam_path:
|
|
# it's a namespace
|
|
ori_leader_family = self.objectspace.space.variables[leader_fam_path]
|
|
else:
|
|
# it's a sub family
|
|
ori_leader_family = self.objectspace.paths.get_family(leader_fam_path,
|
|
leader.namespace,
|
|
)
|
|
has_a_leader = False
|
|
for variable in list(ori_leader_family.variable.values()):
|
|
if isinstance(variable, self.objectspace.leadership) and \
|
|
variable.variable[0].name == leader.name:
|
|
# append follower to an existed leadership
|
|
leader_space = variable
|
|
has_a_leader = True
|
|
elif variable.name == leader.name:
|
|
# it's a leader
|
|
leader_space = self.manage_leader(variable,
|
|
group,
|
|
ori_leader_family,
|
|
)
|
|
has_a_leader = True
|
|
elif has_a_leader:
|
|
# it's should be a follower
|
|
self.manage_follower(follower_names.pop(0),
|
|
leader_fam_path,
|
|
variable,
|
|
leader_space,
|
|
)
|
|
# this variable is not more in ori_leader_family
|
|
ori_leader_family.variable.pop(normalize_family(variable.name))
|
|
if follower_names == []:
|
|
# no more follower
|
|
break
|
|
else:
|
|
joined = '", "'.join(follower_names)
|
|
msg = _(f'when parsing leadership, we espect to find those followers "{joined}"')
|
|
raise DictConsistencyError(msg, 31, variable.xmlfiles)
|
|
del self.objectspace.space.constraints.group
|
|
|
|
def manage_leader(self,
|
|
variable: 'Variable',
|
|
group: 'Group',
|
|
ori_leader_family,
|
|
) -> 'Leadership':
|
|
"""manage leader's variable
|
|
"""
|
|
if variable.multi is not True:
|
|
msg = _(f'the variable "{variable.name}" in a group must be multi')
|
|
raise DictConsistencyError(msg, 32, variable.xmlfiles)
|
|
if hasattr(group, 'name'):
|
|
ori_leadership_name = group.name
|
|
else:
|
|
ori_leadership_name = variable.name
|
|
leadership_name = normalize_family(ori_leadership_name)
|
|
leader_space = self.objectspace.leadership(variable.xmlfiles)
|
|
leader_space.variable = []
|
|
leader_space.name = leadership_name
|
|
leader_space.hidden = variable.hidden
|
|
if variable.hidden:
|
|
variable.frozen = True
|
|
variable.force_default_on_freeze = True
|
|
variable.hidden = None
|
|
if hasattr(group, 'description'):
|
|
leader_space.doc = group.description
|
|
elif variable.name == leadership_name and hasattr(variable, 'description'):
|
|
leader_space.doc = variable.description
|
|
else:
|
|
leader_space.doc = ori_leadership_name
|
|
leadership_path = ori_leader_family.path + '.' + leadership_name
|
|
self.objectspace.paths.add_leadership(variable.namespace,
|
|
leadership_path,
|
|
leader_space,
|
|
)
|
|
ori_leader_family.variable[normalize_family(variable.name)] = leader_space
|
|
leader_space.variable.append(variable)
|
|
self.objectspace.paths.set_leader(variable.namespace,
|
|
ori_leader_family.path,
|
|
leadership_name,
|
|
normalize_family(variable.name),
|
|
)
|
|
return leader_space
|
|
|
|
def manage_follower(self,
|
|
follower_name: str,
|
|
leader_family_name: str,
|
|
variable: 'Variable',
|
|
leader_space: 'Leadership',
|
|
) -> None:
|
|
"""manage follower
|
|
"""
|
|
if variable.name != follower_name:
|
|
msg = _('when parsing leadership, we expect to find the follower '
|
|
f'"{follower_name}" but we found "{variable.name}"')
|
|
raise DictConsistencyError(msg, 33, variable.xmlfiles)
|
|
self.objectspace.paths.set_leader(variable.namespace,
|
|
leader_family_name,
|
|
leader_space.name,
|
|
normalize_family(variable.name),
|
|
)
|
|
if leader_space.hidden:
|
|
variable.frozen = True
|
|
variable.force_default_on_freeze = True
|
|
leader_space.variable.append(variable)
|