rougail/src/rougail/tiramisureflector.py

"""loader
flattened XML specific
"""
from .config import Config
from .annotator import CONVERT_OPTION
from .objspace import RootRougailObject


FUNC_TO_DICT = []
ATTRIBUTES_ORDER = ('name', 'doc', 'default', 'values', 'multi', 'default_multi', 'properties',
                    'validators', 'min_number', 'max_number',
                    )


class Root():  # pylint: disable=R0903
    """Root classes
    """
    path = '.'


class BaseElt:  # pylint: disable=R0903
    """Base element
    """
    name = 'baseoption'
    doc = 'baseoption'
    path = '.'


class TiramisuReflector:
    """Convert object to tiramisu representation
    """
    def __init__(self,
                 objectspace,
                 funcs_path,
                 ):
        self.index = 0
        self.text = ["from importlib.machinery import SourceFileLoader",
                     "from importlib.util import spec_from_loader, module_from_spec",
                     f"loader = SourceFileLoader('func', '{funcs_path}')",
                     "spec = spec_from_loader(loader.name, loader)",
                     "func = module_from_spec(spec)",
                     "loader.exec_module(func)",
                     "for key, value in dict(locals()).items():",
                     "    if key != ['SourceFileLoader', 'func']:",
                     "        setattr(func, key, value)",
                     "try:",
                     "    from tiramisu3 import *",
                     "except:",
                     "    from tiramisu import *",
                     "from rougail.tiramisu import ConvertDynOptionDescription",
                     ]
        self.objectspace = objectspace
        self.make_tiramisu_objects()

    def make_tiramisu_objects(self) -> None:
        """make tiramisu objects
        """
        baseelt = BaseElt()
        self.set_name(baseelt)
        basefamily = Family(baseelt,
                            self.text,
                            False,
                            )
        for elt in self.reorder_family():
            self.populate_family(basefamily,
                                 elt,
                                 )
        # parse object
        baseelt.reflector_object.get()  # pylint: disable=E1101

    def reorder_family(self):
        """variable_namespace family has to be loaded before any other family
        because `extra` family could use `variable_namespace` variables.
        """
        if hasattr(self.objectspace.space, 'variables'):
            if Config['variable_namespace'] in self.objectspace.space.variables:
                yield self.objectspace.space.variables[Config['variable_namespace']]
            for elt, value in self.objectspace.space.variables.items():
                if elt != Config['variable_namespace']:
                    yield value
        if hasattr(self.objectspace.space, 'services'):
            yield self.objectspace.space.services

    def populate_family(self,
                        parent_family,
                        elt,
                        ):
        """Populate family
        """
        self.set_name(elt)
        family = Family(elt,
                        self.text,
                        isinstance(elt, self.objectspace.leadership),
                        )
        parent_family.add(family)
        for children in vars(elt).values():
            if isinstance(children, self.objectspace.family):
                self.populate_family(family,
                                     children,
                                     )
                continue
            if isinstance(children, dict):
                children = list(children.values())
            if isinstance(children, list):
                for child in children:
                    if isinstance(child, self.objectspace.property_) or \
                            not isinstance(child, RootRougailObject):
                        continue
                    if isinstance(child, self.objectspace.variable):
                        function = self.populate_variable
                    else:
                        function = self.populate_family
                    function(family,
                             child,
                             )

    def populate_variable(self,
                          family,
                          elt,
                          ):
        """Populate variable
        """
        if family.is_leadership:
            is_leader = elt.name == family.elt.variable[0].name
            is_follower = not is_leader
        else:
            is_leader = False
            is_follower = False
        self.set_name(elt)
        family.add(Variable(elt,
                            self.text,
                            self.objectspace,
                            is_follower,
                            is_leader,
                            ))

    def set_name(self,
                 elt,
                 ):
        """Set name
        """
        elt.reflector_name = f'option_{self.index}'
        self.index += 1

    def get_text(self):
        """Get text
        """
        return '\n'.join(self.text)


class Common:
    """Common function for variable and family
    """
    def __init__(self,
                 elt,
                 text,
                 ):
        self.elt = elt
        self.option_name = None
        self.attrib = {}
        self.text = text
        self.elt.reflector_object = self

    @staticmethod
    def populate_properties(child) -> str:
        """Populate properties
        """
        assert child.type == 'calculation'
        action = f"ParamValue('{child.name}')"
        option_name = child.source.reflector_object.get()
        kwargs = (f"'condition': ParamOption({option_name}, todict=True), "
                  f"'expected': ParamValue('{child.expected}')")
        if child.inverse:
            kwargs += ", 'reverse_condition': ParamValue(True)"
        return 'Calculation(calc_value, Params(' + action + ', kwargs={' + kwargs + '}))'

    def properties_to_string(self):
        """Change properties to string
        """
        properties = []
        calc_properties = []
        for property_ in self.attrib['properties']:
            if not isinstance(property_, str):
                calc_properties.append(self.populate_properties(property_))
            else:
                properties.append(f"'{property_}'")
        return 'frozenset({' + ', '.join(sorted(properties) + calc_properties) + '})'

    def get_attrib(self):
        """Get attributes
        """
        ret_list = []
        for key, value in self.attrib.items():
            if value is None:
                continue
            if key == 'properties':
                value = self.properties_to_string()
            elif key == 'validators':
                value = '[' + ', '.join([self.calculation_value(val, ['ParamSelfOption()']) \
                        for val in value]) + ']'
            elif key == 'values':
                if value[0].type == 'calculation':
                    value = value[0].name.reflector_object.get()
                    value = f"Calculation(func.calc_value, Params((ParamOption({value}))))"
                else:
                    value = str(tuple([val.name for val in value]))
            elif key in ['multi', 'suffixes']:
                if not value:
                    continue
            elif isinstance(value, str) and key != 'opt' and not value.startswith('['):
                value = "'" + value.replace("'", "\\\'") + "'"
            elif isinstance(value, self.objectspace.value):
                value = self.calculation_value(value, [])
            ret_list.append(f'{key}={value}')
        return ', '.join(ret_list)

    def populate_informations(self):
        """Populate Tiramisu's informations
        """
        if not hasattr(self.elt, 'information'):
            return
        for key, value in vars(self.elt.information).items():
            if key == 'xmlfiles':
                continue
            if isinstance(value, str):
                value = '"' + value.replace('"', '\"') + '"'
            self.text.append(f'{self.option_name}.impl_set_information("{key}", {value})')

    def populate_attrib(self):
        """Populate attributes
        """
        for attr in ATTRIBUTES_ORDER:
            if hasattr(self.elt, attr):
                self.attrib[attr] = getattr(self.elt, attr)


class Variable(Common):
    """Manage variable
    """
    def __init__(self,
                 elt,
                 text,
                 objectspace,
                 is_follower,
                 is_leader,
                 ):
        super().__init__(elt, text)
        self.objectspace = objectspace
        self.is_leader = is_leader
        self.is_follower = is_follower
        convert_option = CONVERT_OPTION[elt.type]
        self.object_type = convert_option['opttype']
        self.attrib.update(convert_option.get('initkwargs', {}))

    def get(self):
        """Get tiramisu's object
        """
        if self.option_name is None:
            self.populate_attrib()
            if self.object_type == 'SymLinkOption':
                self.attrib['opt'] = self.elt.opt.reflector_object.get()
            attrib = self.get_attrib()
            self.option_name = self.elt.reflector_name
            self.text.append(f'{self.option_name} = {self.object_type}({attrib})')
            self.populate_informations()
        return self.option_name

    def calculation_value(self,
                          child,
                          args,
                          ) -> str:
        """Generate calculated value
        """
        kwargs = []
        # has parameters
        function = child.name
        if hasattr(child, 'param'):
            for param in child.param:
                value = self.populate_param(function, param)
                if not hasattr(param, 'name'):
                    args.append(str(value))
                else:
                    kwargs.append(f"'{param.name}': " + value)
        ret = f"Calculation(func.{function}, Params((" + ', '.join(args) + \
                "), kwargs=" + "{" + ', '.join(kwargs) + "})"
        if hasattr(child, 'warnings_only'):
            ret += f', warnings_only={child.warnings_only}'
        return ret + ')'

    def populate_param(self,
                       function: str,
                       param,
                       ):
        """Populate variable parameters
        """
        if param.type == 'string':
            return f'ParamValue("{param.text}")'
        if param.type == 'number':
            return f'ParamValue({param.text})'
        if param.type == 'variable':
            value = {'option': param.text,
                     'notraisepropertyerror': param.notraisepropertyerror,
                     'todict': function in FUNC_TO_DICT,
                     }
            if hasattr(param, 'suffix'):
                value['suffix'] = param.suffix
                value['family'] = param.family
            return self.build_param(value)
        if param.type == 'information':
            return f'ParamInformation("{param.text}", None)'
        if param.type == 'suffix':
            return 'ParamSuffix()'
        return ''  # pragma: no cover

    @staticmethod
    def build_param(param) -> str:
        """build variable parameters
        """
        option_name = param['option'].reflector_object.get()
        ends = f"notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
        if 'suffix' in param:
            family_name = param['family'].reflector_name
            return f"ParamDynOption({option_name}, '{param['suffix']}', {family_name}, {ends}"
        return f"ParamOption({option_name}, {ends}"


class Family(Common):
    """Manage family
    """
    def __init__(self,
                 elt,
                 text,
                 is_leadership
                 ):
        super().__init__(elt, text)
        self.is_leadership = is_leadership
        self.children = []

    def add(self, child):
        """Add a child
        """
        self.children.append(child)

    def get(self):
        """Get tiramisu's object
        """
        if not self.option_name:
            self.populate_attrib()
            self.populate_dynamic()
            self.option_name = self.elt.reflector_name
            object_name = self.get_object_name()
            attrib = self.get_attrib() + \
                    ', children=[' + ', '.join([child.get() for child in self.children]) + ']'
            self.text.append(f'{self.option_name} = {object_name}({attrib})')
            self.populate_informations()
        return self.option_name

    def populate_dynamic(self):
        """populate dynamic family
        """
        if hasattr(self.elt, 'dynamic'):
            dyn = self.elt.dynamic.reflector_object.get()
            self.attrib['suffixes'] = f"Calculation(func.calc_value, Params((ParamOption({dyn}))))"

    def get_object_name(self):
        """Get family object's name
        """
        if 'suffixes' in self.attrib:
            return 'ConvertDynOptionDescription'
        if self.is_leadership:
            return 'Leadership'
        return 'OptionDescription'