rougail/src/rougail/objspace.py

"""
Takes a bunch of Rougail XML dispatched in differents folders
as an input and outputs a Tiramisu's file

Sample usage::

    >>> from rougail.objspace import RougailObjSpace
    >>> eolobj = RougailObjSpace('/usr/share/rougail/rougail.dtd')
    >>> eolobj.create_or_populate_from_xml('rougail', ['/usr/share/rougail/dicos'])
    >>> eolobj.space_visitor('/usr/share/rougail/funcs.py')
    >>> tiramisu = eolobj.save()

The RougailObjSpace

- loads the XML into an internal RougailObjSpace representation
- visits/annotates the objects
- dumps the object space as Tiramisu string

The visit/annotation stage is a complex step that corresponds to the Rougail
procedures.
"""

from typing import List

from .i18n import _
from .xmlreflector import XMLReflector
from .annotator import SpaceAnnotator
from .tiramisureflector import TiramisuReflector
from .utils import normalize_family
from .error import OperationError, SpaceObjShallNotBeUpdated, DictConsistencyError
from .path import Path
from .config import Config

# RougailObjSpace's elements that shall be forced to the Redefinable type
FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
# RougailObjSpace's elements that shall be forced to the UnRedefinable type
FORCE_UNREDEFINABLES = ('value',)
# RougailObjSpace's elements that shall not be modify
UNREDEFINABLE = ('multi', 'type')
# RougailObjSpace's elements that did not created automaticly
FORCE_ELEMENTS = ('choice', 'property_', 'leadership')
# XML text are convert has name
FORCED_TEXT_ELTS_AS_NAME = ('choice', 'property', 'value', 'target')


# _____________________________________________________________________________
# special types definitions for the Object Space's internal representation
class RootRougailObject:
    def __init__(self, xmlfiles):
        if not isinstance(xmlfiles, list):
            xmlfiles = [xmlfiles]
        self.xmlfiles = xmlfiles


class Atom(RootRougailObject):
    pass


class Redefinable(RootRougailObject):
    pass


class UnRedefinable(RootRougailObject):
    pass


class ObjSpace:
    """
    Base object space
    """
    pass


class RougailObjSpace:
    """Rougail ObjectSpace is an object's reflexion of the XML elements
    """

    def __init__(self, dtdfilename):
        self.index = 0
        self.space = ObjSpace()
        self.paths = Path()
        self.xmlreflector = XMLReflector()
        self.xmlreflector.parse_dtd(dtdfilename)
        self.redefine_variables = None

        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_classes()

    def make_object_space_classes(self):
        """Create Rougail ObjectSpace class types from DDT file
        It enables us to create objects like:
        File(), Variable(), Ip(), Family(), Constraints()... and so on.
        """

        for dtd_elt in self.xmlreflector.dtd.iterelements():
            attrs = {}
            if dtd_elt.name in FORCE_REDEFINABLES:
                clstype = Redefinable
            elif not dtd_elt.attributes() and dtd_elt.name not in FORCE_UNREDEFINABLES:
                clstype = Atom
            else:
                clstype = UnRedefinable
            forced_text_elt = dtd_elt.type == 'mixed'
            for dtd_attr in dtd_elt.iterattributes():
                if set(dtd_attr.itervalues()) == {'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(default_value)
                    attrs[dtd_attr.name] = default_value
                if dtd_attr.name == 'redefine':
                    # has a redefine attribute, so it's a Redefinable object
                    clstype = 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)

            # create ObjectSpace object
            setattr(self, dtd_elt.name, type(dtd_elt.name.capitalize(), (clstype,), attrs))
        for elt in FORCE_ELEMENTS:
            name = elt.capitalize()
            if name.endswith('_'):
                name = name[:-1]
            setattr(self, elt, type(name, (RootRougailObject,), dict()))
        self.Leadership = self.leadership

    def display_xmlfiles(self,
                         xmlfiles: list,
                         ) -> str:
        if len(xmlfiles) == 1:
            return '"' + xmlfiles[0] + '"'
        return '"' + '", "'.join(xmlfiles[:-1]) + '"' + ' and ' + '"' + xmlfiles[-1] + '"'

    def create_or_populate_from_xml(self,
                                    namespace: str,
                                    xmlfolders: List[str],
                                    ) -> List[str]:
        """Parses a bunch of XML files and populates the RougailObjSpace
        """
        for xmlfile in self.xmlreflector.load_xml_from_folders(xmlfolders):
            document = self.xmlreflector.parse_xmlfile(xmlfile)
            self.redefine_variables = []
            self.xml_parse_document(xmlfile,
                                    document,
                                    self.space,
                                    namespace,
                                    )

    def xml_parse_document(self,
                           xmlfile,
                           document,
                           space,
                           namespace,
                           ):
        """Parses a Rougail XML file and populates the RougailObjSpace
        """
        # var to check unique family name in a XML file
        family_names = []
        for child in document:
            # this index enables us to reorder objects
            if not isinstance(child.tag, str):
                # doesn't proceed the XML commentaries
                continue
            if child.tag == 'family':
                if child.attrib['name'] in family_names:
                    raise DictConsistencyError(_(f'Family "{child.attrib["name"]}" is set several times in "{xmlfile}"'), 44)
                family_names.append(child.attrib['name'])
            if child.tag == 'variables':
                # variables has no name, so force namespace name
                child.attrib['name'] = namespace
            if child.tag == 'value' and child.text is None:
                # remove empty value
                continue
            # variable objects creation
            try:
                variableobj = self.get_variableobj(xmlfile,
                                                   child,
                                                   space,
                                                   namespace,
                                                   )
            except SpaceObjShallNotBeUpdated:
                continue
            self.index += 1
            self.set_text(child,
                          variableobj,
                          )
            self.set_attributes(xmlfile,
                                child,
                                variableobj,
                                )
            self.remove(child,
                        variableobj,
                        )
            self.set_path(space,
                          child,
                          namespace,
                          document,
                          variableobj,
                          )
            self.add_to_tree_structure(variableobj,
                                       space,
                                       child,
                                       namespace,
                                       )
            if list(child) != []:
                self.xml_parse_document(xmlfile,
                                        child,
                                        variableobj,
                                        namespace,
                                        )

    def get_variableobj(self,
                        xmlfile: str,
                        child: list,
                        space,
                        namespace,
                        ):
        """
        retrieves or creates Rougail Object Subspace objects
        """
        obj = getattr(self, child.tag)
        if Redefinable in obj.__mro__:
            return self.create_or_update_redefinable_object(xmlfile,
                                                            child.attrib,
                                                            space,
                                                            child,
                                                            namespace,
                                                            )
        elif Atom in obj.__mro__:
            if child.tag in vars(space):
                # Atom instance has to be a singleton here
                # we do not re-create it, we reuse it
                return getattr(space, child.tag)
            return obj(xmlfile)
        if child.tag not in vars(space):
            setattr(space, child.tag, [])
        return obj(xmlfile)

    def create_or_update_redefinable_object(self,
                                            xmlfile,
                                            subspace,
                                            space,
                                            child,
                                            namespace,
                                            ):
        if child.tag in self.forced_text_elts_as_name:
            name = child.text
        else:
            name = subspace['name']
        if child.tag == 'family':
            name = normalize_family(name)
        existed_var = self.get_existed_obj(name,
                                           space,
                                           child,
                                           namespace,
                                           )
        if existed_var:
            # if redefine is set to object, default value is False
            # otherwise it's always a redefinable object
            default_redefine = child.tag in FORCE_REDEFINABLES
            redefine = self.convert_boolean(subspace.get('redefine', default_redefine))
            if redefine is True:
                existed_var.xmlfiles.append(xmlfile)
                return existed_var
            exists = self.convert_boolean(subspace.get('exists', True))
            if exists is False:
                raise SpaceObjShallNotBeUpdated()
            xmlfiles = self.display_xmlfiles(existed_var.xmlfiles)
            raise DictConsistencyError(_(f'"{child.tag}" named "{name}" cannot be re-created in "{xmlfile}", already defined in {xmlfiles}'), 45)
        # if this object must only be modified if object already exists
        exists = self.convert_boolean(subspace.get('exists', False))
        if exists is True:
            raise SpaceObjShallNotBeUpdated()
        redefine = self.convert_boolean(subspace.get('redefine', False))
        if redefine is False:
            if child.tag not in vars(space):
                setattr(space, child.tag, {})
            return getattr(self, child.tag)(xmlfile)
        raise DictConsistencyError(_(f'Redefined object in "{xmlfile}": "{name}" does not exist yet'), 46)

    def get_existed_obj(self,
                        name: str,
                        space: str,
                        child,
                        namespace: str,
                        ):
        if isinstance(space, self.family):
            if namespace != Config['variable_namespace']:
                name = space.path + '.' + name
            if not self.paths.path_is_defined(name):
                return
            old_family_name = self.paths.get_variable_family_name(name)
            if namespace != Config['variable_namespace']:
                old_family_name = namespace + '.' + old_family_name
            if space.path != old_family_name:
                xmlfiles = self.display_xmlfiles(space.xmlfiles)
                raise DictConsistencyError(_(f'Variable was previously create in family "{old_family_name}", now it is in "{space.path}" in {xmlfiles}'), 47)
            return self.paths.get_variable_obj(name)
        children = getattr(space, child.tag, {})
        if name in children:
            return children[name]

    def convert_boolean(self, value):
        """Boolean coercion. The Rougail XML may contain srings like `True` or `False`
        """
        if isinstance(value, bool):
            return value
        if value == 'True':
            return True
        return False

    def set_text(self,
                 child,
                 variableobj,
                 ):
        if child.text is None:
            return
        text = child.text.strip()
        if not text:
            return
        if child.tag in self.forced_text_elts_as_name:
            variableobj.name = text
        else:
            variableobj.text = text

    def set_attributes(self,
                       xmlfile,
                       child,
                       variableobj,
                       ):
        redefine = self.convert_boolean(child.attrib.get('redefine', False))
        if redefine and child.tag == 'variable':
            # delete old values
            has_value = hasattr(variableobj, 'value')
            if has_value and len(child) != 0:
                del variableobj.value
        for attr, val in child.attrib.items():
            if redefine and attr in UNREDEFINABLE:
                xmlfiles = self.display_xmlfiles(variableobj.xmlfiles[:-1])
                raise DictConsistencyError(_(f'cannot redefine attribute "{attr}" for variable "{child.attrib["name"]}" in "{xmlfile}", already defined in {xmlfiles}'), 48)
            if attr in self.booleans_attributs:
                val = self.convert_boolean(val)
            if attr == 'name' and getattr(variableobj, 'name', None):
                # do not redefine name
                continue
            setattr(variableobj, attr, val)

    def remove(self,
               child,
               variableobj,
               ):
        """Rougail 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.attrib.get('remove_fill', False):
                self.remove_fill(variableobj.name)
        if child.tag == 'fill' and child.attrib['target'] in self.redefine_variables:
            self.remove_fill(child.attrib['target'])

    def remove_check(self, name):
        if hasattr(self.space, 'constraints') and hasattr(self.space.constraints, 'check'):
            remove_checks = []
            for idx, check in enumerate(self.space.constraints.check):
                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)

    def remove_condition(self, name):
        remove_conditions = []
        for idx, condition in enumerate(self.space.constraints.condition):
            if condition.source == name:
                remove_conditions.append(idx)
        for idx in remove_conditions:
            del self.space.constraints.condition[idx]

    def remove_fill(self, name):
        if hasattr(self.space, 'constraints') and hasattr(self.space.constraints, 'fill'):
            remove_fills= []
            for idx, fill in enumerate(self.space.constraints.fill):
                if hasattr(fill, 'target') and fill.target == name:
                    remove_fills.append(idx)

            remove_fills = list(set(remove_fills))
            remove_fills.sort(reverse=True)
            for idx in remove_fills:
                self.space.constraints.fill.pop(idx)

    def set_path(self,
                 space,
                 child,
                 namespace,
                 document,
                 variableobj,
                 ):
        """Fill self.paths attributes
        """
        if child.tag == 'variable':
            family_name = document.attrib['name']
            family_name = normalize_family(family_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 == Config['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 != Config['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 add_to_tree_structure(self,
                              variableobj,
                              space,
                              child,
                              namespace,
                              ):
        if not hasattr(variableobj, 'index'):
            variableobj.index = self.index
        variableobj.namespace = namespace
        if isinstance(variableobj, Redefinable):
            name = variableobj.name
            if child.tag == 'family':
                name = normalize_family(name)
            getattr(space, child.tag)[name] = variableobj
        elif isinstance(variableobj, UnRedefinable):
            getattr(space, child.tag).append(variableobj)
        else:
            setattr(space, child.tag, variableobj)

    def space_visitor(self, eosfunc_file):
        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'