530 lines
23 KiB
Python
530 lines
23 KiB
Python
"""
|
|
Creole flattener. Takes a bunch of Creole XML dispatched in differents folders
|
|
as an input and outputs a human readable flatened XML
|
|
|
|
Sample usage::
|
|
|
|
>>> from rougail.objspace import CreoleObjSpace
|
|
>>> eolobj = CreoleObjSpace('/usr/share/rougail/rougail.dtd')
|
|
>>> eolobj.create_or_populate_from_xml('rougail', ['/usr/share/eole/rougail/dicos'])
|
|
>>> eolobj.space_visitor()
|
|
>>> eolobj.save('/tmp/rougail_flatened_output.xml')
|
|
|
|
The CreoleObjSpace
|
|
|
|
- loads the XML into an internal CreoleObjSpace representation
|
|
- visits/annotates the objects
|
|
- dumps the object space as XML output into a single XML target
|
|
|
|
The visit/annotation stage is a complex step that corresponds to the Creole
|
|
procedures.
|
|
|
|
For example: a variable is redefined and shall be moved to another family
|
|
means that a variable1 = Variable() object in the object space who lives in the family1 parent
|
|
has to be moved in family2. The visit procedure changes the varable1's object space's parent.
|
|
"""
|
|
from lxml.etree import Element, SubElement # pylint: disable=E0611
|
|
|
|
from .i18n import _
|
|
from .xmlreflector import XMLReflector
|
|
from .annotator import ERASED_ATTRIBUTES, SpaceAnnotator
|
|
from .tiramisureflector import TiramisuReflector
|
|
from .utils import normalize_family
|
|
from .error import OperationError, SpaceObjShallNotBeUpdated, DictConsistencyError
|
|
from .path import Path
|
|
from .config import variable_namespace
|
|
|
|
# CreoleObjSpace's elements like 'family' or 'follower', that shall be forced to the Redefinable type
|
|
FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
|
|
# CreoleObjSpace's elements that shall be forced to the UnRedefinable type
|
|
FORCE_UNREDEFINABLES = ('value',)
|
|
# CreoleObjSpace's elements that shall be set to the UnRedefinable type
|
|
UNREDEFINABLE = ('multi', 'type')
|
|
|
|
CONVERT_PROPERTIES = {'auto_save': ['force_store_value'], 'auto_freeze': ['force_store_value', 'auto_freeze']}
|
|
|
|
RENAME_ATTIBUTES = {'description': 'doc'}
|
|
|
|
FORCED_TEXT_ELTS_AS_NAME = ('choice', 'property', 'value', 'target')
|
|
|
|
CONVERT_EXPORT = {'Leadership': 'leader',
|
|
'Variable': 'variable',
|
|
'Value': 'value',
|
|
'Property': 'property',
|
|
'Choice': 'choice',
|
|
'Param': 'param',
|
|
'Check': 'check',
|
|
}
|
|
|
|
# _____________________________________________________________________________
|
|
# special types definitions for the Object Space's internal representation
|
|
class RootCreoleObject:
|
|
""
|
|
|
|
|
|
class CreoleObjSpace:
|
|
"""DOM XML reflexion free internal representation of a Creole Dictionary
|
|
"""
|
|
choice = type('Choice', (RootCreoleObject,), dict())
|
|
property_ = type('Property', (RootCreoleObject,), dict())
|
|
# Creole ObjectSpace's Leadership variable class type
|
|
Leadership = type('Leadership', (RootCreoleObject,), dict())
|
|
"""
|
|
This Atom type stands for singleton, that is
|
|
an Object Space's atom object is present only once in the
|
|
object space's tree
|
|
"""
|
|
Atom = type('Atom', (RootCreoleObject,), dict())
|
|
"A variable that can't be redefined"
|
|
Redefinable = type('Redefinable', (RootCreoleObject,), dict())
|
|
"A variable can be redefined"
|
|
UnRedefinable = type('UnRedefinable', (RootCreoleObject,), dict())
|
|
|
|
|
|
def __init__(self, dtdfilename): # pylint: disable=R0912
|
|
self.index = 0
|
|
class ObjSpace: # pylint: disable=R0903
|
|
"""
|
|
Base object space
|
|
"""
|
|
self.space = ObjSpace()
|
|
self.paths = Path()
|
|
self.xmlreflector = XMLReflector()
|
|
self.xmlreflector.parse_dtd(dtdfilename)
|
|
self.redefine_variables = None
|
|
self.check_removed = None
|
|
self.condition_removed = None
|
|
|
|
# ['variable', 'separator', 'family']
|
|
self.forced_text_elts = set()
|
|
self.forced_text_elts_as_name = set(FORCED_TEXT_ELTS_AS_NAME)
|
|
self.list_conditions = {}
|
|
self.booleans_attributs = []
|
|
|
|
self.make_object_space_class()
|
|
|
|
def make_object_space_class(self):
|
|
"""Create Rougail ObjectSpace class types, it enables us to create objects like:
|
|
File(), Variable(), Ip(), Family(), Constraints()... and so on.
|
|
|
|
Creole ObjectSpace is an object's reflexion of the XML elements"""
|
|
|
|
for dtd_elt in self.xmlreflector.dtd.iterelements():
|
|
attrs = {}
|
|
if dtd_elt.name in FORCE_REDEFINABLES:
|
|
clstype = self.Redefinable
|
|
else:
|
|
clstype = self.UnRedefinable
|
|
atomic = dtd_elt.name not in FORCE_UNREDEFINABLES and dtd_elt.name not in FORCE_REDEFINABLES
|
|
forced_text_elt = dtd_elt.type == 'mixed'
|
|
for dtd_attr in dtd_elt.iterattributes():
|
|
atomic = False
|
|
if set(dtd_attr.itervalues()) == set(['True', 'False']):
|
|
# it's a boolean
|
|
self.booleans_attributs.append(dtd_attr.name)
|
|
if dtd_attr.default_value:
|
|
# set default value for this attribute
|
|
default_value = dtd_attr.default_value
|
|
if dtd_attr.name in self.booleans_attributs:
|
|
default_value = self.convert_boolean(dtd_attr.default_value)
|
|
attrs[dtd_attr.name] = default_value
|
|
if dtd_attr.name == 'redefine':
|
|
# has a redefine attribute, so it's a Redefinable object
|
|
clstype = self.Redefinable
|
|
if dtd_attr.name == 'name' and forced_text_elt:
|
|
# child.text should be transform has a "name" attribute
|
|
self.forced_text_elts.add(dtd_elt.name)
|
|
forced_text_elt = False
|
|
|
|
if forced_text_elt is True:
|
|
self.forced_text_elts_as_name.add(dtd_elt.name)
|
|
if atomic:
|
|
# has any attribute so it's an Atomic object
|
|
clstype = self.Atom
|
|
|
|
# create ObjectSpace object
|
|
setattr(self, dtd_elt.name, type(dtd_elt.name.capitalize(), (clstype,), attrs))
|
|
|
|
def create_or_populate_from_xml(self,
|
|
namespace,
|
|
xmlfolders):
|
|
"""Parses a bunch of XML files
|
|
populates the CreoleObjSpace
|
|
"""
|
|
for xmlfile, document in self.xmlreflector.load_xml_from_folders(xmlfolders):
|
|
self.redefine_variables = []
|
|
self.check_removed = []
|
|
self.condition_removed = []
|
|
self.xml_parse_document(document,
|
|
self.space,
|
|
namespace,
|
|
)
|
|
|
|
def xml_parse_document(self,
|
|
document,
|
|
space,
|
|
namespace,
|
|
):
|
|
"""Parses a Creole XML file
|
|
populates the CreoleObjSpace
|
|
"""
|
|
family_names = []
|
|
for child in document:
|
|
# this index enables us to reorder objects
|
|
self.index += 1
|
|
# doesn't proceed the XML commentaries
|
|
if not isinstance(child.tag, str):
|
|
continue
|
|
if child.tag == 'family':
|
|
if child.attrib['name'] in family_names:
|
|
raise DictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
|
|
family_names.append(child.attrib['name'])
|
|
if child.tag == 'variables':
|
|
child.attrib['name'] = namespace
|
|
if child.tag == 'value' and child.text == None:
|
|
# FIXME should not be here
|
|
continue
|
|
# variable objects creation
|
|
try:
|
|
variableobj = self.generate_variableobj(child,
|
|
space,
|
|
namespace,
|
|
)
|
|
except SpaceObjShallNotBeUpdated:
|
|
continue
|
|
self.set_text_to_obj(child,
|
|
variableobj,
|
|
)
|
|
self.set_xml_attributes_to_obj(child,
|
|
variableobj,
|
|
)
|
|
self.variableobj_tree_visitor(child,
|
|
variableobj,
|
|
namespace,
|
|
)
|
|
self.fill_variableobj_path_attribute(space,
|
|
child,
|
|
namespace,
|
|
document,
|
|
variableobj,
|
|
)
|
|
self.add_to_tree_structure(variableobj,
|
|
space,
|
|
child,
|
|
)
|
|
if list(child) != []:
|
|
self.xml_parse_document(child,
|
|
variableobj,
|
|
namespace,
|
|
)
|
|
|
|
def generate_variableobj(self,
|
|
child,
|
|
space,
|
|
namespace,
|
|
):
|
|
"""
|
|
instanciates or creates Creole Object Subspace objects
|
|
"""
|
|
variableobj = getattr(self, child.tag)()
|
|
if isinstance(variableobj, self.Redefinable):
|
|
variableobj = self.create_or_update_redefinable_object(child.attrib,
|
|
space,
|
|
child,
|
|
namespace,
|
|
)
|
|
elif isinstance(variableobj, self.Atom) and child.tag in vars(space):
|
|
# instanciates an object from the CreoleObjSpace's builtins types
|
|
# example : child.tag = constraints -> a self.Constraints() object is created
|
|
# this Atom instance has to be a singleton here
|
|
# we do not re-create it, we reuse it
|
|
variableobj = getattr(space, child.tag)
|
|
self.create_tree_structure(space,
|
|
child,
|
|
variableobj,
|
|
)
|
|
return variableobj
|
|
|
|
def create_or_update_redefinable_object(self,
|
|
subspace,
|
|
space,
|
|
child,
|
|
namespace,
|
|
):
|
|
"""Creates or retrieves the space object that corresponds
|
|
to the `child` XML object
|
|
|
|
Two attributes of the `child` XML object are important:
|
|
|
|
- with the `redefine` boolean flag attribute we know whether
|
|
the corresponding space object shall be created or updated
|
|
|
|
- `True` means that the corresponding space object shall be updated
|
|
- `False` means that the corresponding space object shall be created
|
|
|
|
- with the `exists` boolean flag attribute we know whether
|
|
the corresponding space object shall be created
|
|
(or nothing -- that is the space object isn't modified)
|
|
|
|
- `True` means that the corresponding space object shall be created
|
|
- `False` means that the corresponding space object is not updated
|
|
|
|
In the special case `redefine` is True and `exists` is False,
|
|
we create the corresponding space object if it doesn't exist
|
|
and we update it if it exists.
|
|
|
|
:return: the corresponding space object of the `child` XML object
|
|
"""
|
|
if child.tag in self.forced_text_elts_as_name:
|
|
name = child.text
|
|
else:
|
|
name = subspace['name']
|
|
if self.is_already_exists(name,
|
|
space,
|
|
child,
|
|
namespace,
|
|
):
|
|
default_redefine = child.tag in FORCE_REDEFINABLES
|
|
redefine = self.convert_boolean(subspace.get('redefine', default_redefine))
|
|
exists = self.convert_boolean(subspace.get('exists', True))
|
|
if redefine is True:
|
|
return self.translate_in_space(name,
|
|
space,
|
|
child,
|
|
namespace,
|
|
)
|
|
elif exists is False:
|
|
raise SpaceObjShallNotBeUpdated()
|
|
raise DictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
|
|
redefine = self.convert_boolean(subspace.get('redefine', False))
|
|
exists = self.convert_boolean(subspace.get('exists', False))
|
|
if redefine is False or exists is True:
|
|
return getattr(self, child.tag)()
|
|
raise DictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
|
|
|
|
def create_tree_structure(self,
|
|
space,
|
|
child,
|
|
variableobj,
|
|
): # pylint: disable=R0201
|
|
"""
|
|
Builds the tree structure of the object space here
|
|
we set services attributes in order to be populated later on
|
|
for example::
|
|
|
|
space = Family()
|
|
space.variable = dict()
|
|
another example:
|
|
space = Variable()
|
|
space.value = list()
|
|
"""
|
|
if child.tag not in vars(space):
|
|
if isinstance(variableobj, self.Redefinable):
|
|
setattr(space, child.tag, dict())
|
|
elif isinstance(variableobj, self.UnRedefinable):
|
|
setattr(space, child.tag, [])
|
|
elif not isinstance(variableobj, self.Atom): # pragma: no cover
|
|
raise OperationError(_("Creole object {} "
|
|
"has a wrong type").format(type(variableobj)))
|
|
|
|
def is_already_exists(self, name, space, child, namespace):
|
|
if isinstance(space, self.family): # pylint: disable=E1101
|
|
if namespace != variable_namespace:
|
|
name = space.path + '.' + name
|
|
return self.paths.path_is_defined(name)
|
|
if child.tag == 'family':
|
|
norm_name = normalize_family(name)
|
|
else:
|
|
norm_name = name
|
|
return norm_name in getattr(space, child.tag, {})
|
|
|
|
def convert_boolean(self, value): # pylint: disable=R0201
|
|
"""Boolean coercion. The Creole XML may contain srings like `True` or `False`
|
|
"""
|
|
if isinstance(value, bool):
|
|
return value
|
|
if value == 'True':
|
|
return True
|
|
elif value == 'False':
|
|
return False
|
|
else:
|
|
raise TypeError(_('{} is not True or False').format(value)) # pragma: no cover
|
|
|
|
def translate_in_space(self,
|
|
name,
|
|
family,
|
|
variable,
|
|
namespace,
|
|
):
|
|
if not isinstance(family, self.family): # pylint: disable=E1101
|
|
if variable.tag == 'family':
|
|
norm_name = normalize_family(name)
|
|
else:
|
|
norm_name = name
|
|
return getattr(family, variable.tag)[norm_name]
|
|
if namespace == variable_namespace:
|
|
path = name
|
|
else:
|
|
path = family.path + '.' + name
|
|
old_family_name = self.paths.get_variable_family_name(path)
|
|
if normalize_family(family.name) == old_family_name:
|
|
return getattr(family, variable.tag)[name]
|
|
old_family = self.space.variables[variable_namespace].family[old_family_name] # pylint: disable=E1101
|
|
variable_obj = old_family.variable[name]
|
|
del old_family.variable[name]
|
|
if 'variable' not in vars(family):
|
|
family.variable = dict()
|
|
family.variable[name] = variable_obj
|
|
self.paths.add_variable(namespace,
|
|
name,
|
|
family.name,
|
|
False,
|
|
variable_obj,
|
|
)
|
|
return variable_obj
|
|
|
|
def remove_check(self, name): # pylint: disable=C0111
|
|
if hasattr(self.space, 'constraints') and hasattr(self.space.constraints, 'check'):
|
|
remove_checks = []
|
|
for idx, check in enumerate(self.space.constraints.check): # pylint: disable=E1101
|
|
if hasattr(check, 'target') and check.target == name:
|
|
remove_checks.append(idx)
|
|
|
|
remove_checks = list(set(remove_checks))
|
|
remove_checks.sort(reverse=True)
|
|
for idx in remove_checks:
|
|
self.space.constraints.check.pop(idx) # pylint: disable=E1101
|
|
|
|
def remove_condition(self, name): # pylint: disable=C0111
|
|
for idx, condition in enumerate(self.space.constraints.condition): # pylint: disable=E1101
|
|
remove_targets = []
|
|
if hasattr(condition, 'target'):
|
|
for target_idx, target in enumerate(condition.target):
|
|
if target.name == name:
|
|
remove_targets.append(target_idx)
|
|
remove_targets = list(set(remove_targets))
|
|
remove_targets.sort(reverse=True)
|
|
for idx in remove_targets:
|
|
del condition.target[idx]
|
|
|
|
def add_to_tree_structure(self,
|
|
variableobj,
|
|
space,
|
|
child,
|
|
): # pylint: disable=R0201
|
|
if isinstance(variableobj, self.Redefinable):
|
|
name = variableobj.name
|
|
if child.tag == 'family':
|
|
name = normalize_family(name)
|
|
getattr(space, child.tag)[name] = variableobj
|
|
elif isinstance(variableobj, self.UnRedefinable):
|
|
getattr(space, child.tag).append(variableobj)
|
|
else:
|
|
setattr(space, child.tag, variableobj)
|
|
|
|
def set_text_to_obj(self,
|
|
child,
|
|
variableobj,
|
|
):
|
|
if child.text is None:
|
|
text = None
|
|
else:
|
|
text = child.text.strip()
|
|
if text:
|
|
if child.tag in self.forced_text_elts_as_name:
|
|
variableobj.name = text
|
|
else:
|
|
variableobj.text = text
|
|
|
|
def set_xml_attributes_to_obj(self,
|
|
child,
|
|
variableobj,
|
|
):
|
|
redefine = self.convert_boolean(child.attrib.get('redefine', False))
|
|
has_value = hasattr(variableobj, 'value')
|
|
if redefine is True and child.tag == 'variable' and has_value and len(child) != 0:
|
|
del variableobj.value
|
|
for attr, val in child.attrib.items():
|
|
if redefine and attr in UNREDEFINABLE:
|
|
# UNREDEFINABLE concerns only 'variable' node so we can fix name
|
|
# to child.attrib['name']
|
|
name = child.attrib['name']
|
|
raise DictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
|
|
if attr in self.booleans_attributs:
|
|
val = self.convert_boolean(val)
|
|
if not (attr == 'name' and getattr(variableobj, 'name', None) != None):
|
|
setattr(variableobj, attr, val)
|
|
keys = list(vars(variableobj).keys())
|
|
|
|
def variableobj_tree_visitor(self,
|
|
child,
|
|
variableobj,
|
|
namespace,
|
|
):
|
|
"""Creole object tree manipulations
|
|
"""
|
|
if child.tag == 'variable':
|
|
if child.attrib.get('remove_check', False):
|
|
self.remove_check(variableobj.name)
|
|
if child.attrib.get('remove_condition', False):
|
|
self.remove_condition(variableobj.name)
|
|
if child.tag == 'fill':
|
|
# if variable is a redefine in current dictionary
|
|
# XXX not working with variable not in variable and in leader/followers
|
|
variableobj.redefine = child.attrib['target'] in self.redefine_variables
|
|
if not hasattr(variableobj, 'index'):
|
|
variableobj.index = self.index
|
|
if child.tag == 'check' and child.attrib['target'] in self.redefine_variables and child.attrib['target'] not in self.check_removed:
|
|
self.remove_check(child.attrib['target'])
|
|
self.check_removed.append(child.attrib['target'])
|
|
if child.tag == 'condition' and child.attrib['source'] in self.redefine_variables and child.attrib['source'] not in self.check_removed:
|
|
self.remove_condition(child.attrib['source'])
|
|
self.condition_removed.append(child.attrib['source'])
|
|
variableobj.namespace = namespace
|
|
|
|
def fill_variableobj_path_attribute(self,
|
|
space,
|
|
child,
|
|
namespace,
|
|
document,
|
|
variableobj,
|
|
): # pylint: disable=R0913
|
|
"""Fill self.paths attributes
|
|
"""
|
|
if isinstance(space, self.help): # pylint: disable=E1101
|
|
return
|
|
if child.tag == 'variable':
|
|
family_name = normalize_family(document.attrib['name'])
|
|
self.paths.add_variable(namespace,
|
|
child.attrib['name'],
|
|
family_name,
|
|
document.attrib.get('dynamic') != None,
|
|
variableobj)
|
|
if child.attrib.get('redefine', 'False') == 'True':
|
|
if namespace == variable_namespace:
|
|
self.redefine_variables.append(child.attrib['name'])
|
|
else:
|
|
self.redefine_variables.append(namespace + '.' + family_name + '.' +
|
|
child.attrib['name'])
|
|
|
|
elif child.tag == 'family':
|
|
family_name = normalize_family(child.attrib['name'])
|
|
if namespace != variable_namespace:
|
|
family_name = namespace + '.' + family_name
|
|
self.paths.add_family(namespace,
|
|
family_name,
|
|
variableobj,
|
|
)
|
|
variableobj.path = self.paths.get_family_path(family_name, namespace)
|
|
|
|
def space_visitor(self, eosfunc_file): # pylint: disable=C0111
|
|
self.funcs_path = eosfunc_file
|
|
SpaceAnnotator(self, eosfunc_file)
|
|
|
|
def save(self,
|
|
):
|
|
tiramisu_objects = TiramisuReflector(self.space,
|
|
self.funcs_path,
|
|
)
|
|
return tiramisu_objects.get_text() + '\n'
|