calculate-utils-4-lib/calculate/templates/format/base_format.py

# vim: fileencoding=utf-8
#
from collections import OrderedDict
from jinja2 import Environment, PackageLoader
from pprint import pprint
from copy import copy
try:
    from lxml.etree.ElementTree import fromstring
except ImportError:
    from xml.etree.ElementTree import fromstring


class FormatError(Exception):
    pass


class BaseFormat():
    FORMAT = 'none'

    def __init__(self, processing_methods):
        self._processing_methods = processing_methods
        self._document_dictionary = OrderedDict()
        self._item_to_add = OrderedDict()

        self.TEMPLATES_DIRECTORY = 'templates'

        self._fatal_error_flag = False
        self._ready_to_update = False
        self._match = False

        self._need_finish = False
        self._comments_processing = False

        self._join_before = False
        self._join_before_in_areas = False

        # для отладки.
        self._line_timer = 0

    def _lines_to_dictionary(self, document_lines):
        # print('Lines processing...')
        for line in document_lines:
            # print(self._line_timer, '\t', line)
            for processing_method in self._processing_methods:
                processing_method(line)

                if self._fatal_error_flag:
                    # Действия если файл невозможно разобрать.
                    self._document_dictionary = OrderedDict()
                    raise FormatError('line {} is not correct.'.
                                      format(self._line_timer))

                if self._is_match():
                    if self._is_ready_to_update():
                        self._document_dictionary.update(self._item_to_add)
                    break
            else:
                # Действия если не удалось разобрать строку.
                self._document_dictionary = OrderedDict()
                raise FormatError('line {} is not correct.'.
                                  format(self._line_timer))

            self._line_timer += 1

        if self._need_finish:
            self._finish_method()

    def _parse_xml_to_dictionary(self, xml_document_text):
        root = fromstring(xml_document_text)
        self._document_dictionary = self._processing_methods[root.tag](root)

    def print_dictionary(self):
        pprint(self._document_dictionary)

    def join_template(self, template):
        self._join(self._document_dictionary,
                   template._document_dictionary,
                   self._join_before)

    def _get_list_of_logic_lines(self, text):
        list_of_lines = []
        lines_to_join = []
        for line in text.splitlines():
            line = line.strip()
            if line == '':
                continue
            if not line.endswith("\\"):
                lines_to_join.append(line)
                joined_line = "".join(lines_to_join)
                list_of_lines.append(joined_line)
                lines_to_join = []
            else:
                lines_to_join.append(line[:-1])
        return list_of_lines

    def _join(self, original, template, join_before):
        if template == OrderedDict():
            return
        if join_before:
            forwarded_items = OrderedDict()
        for key_value in template:
            if key_value[0] == '!':
                # Удаление соответствующего элемента из original.
                # Сначала получаем ключ без символа действия.
                if isinstance(key_value, tuple):
                    item_to_delete = ('',) + key_value[1:]
                elif isinstance(key_value, str):
                    item_to_delete = key_value[1:]

                # Удаляем соответствующий элемент, если он есть в оригинале.
                if item_to_delete in original.keys():
                    del(original[item_to_delete])
            elif key_value[0] == '-':
                # Замена соответствующего элемента из original.
                # Сначала получаем ключ без символа действия.
                if isinstance(key_value, tuple):
                    item_to_replace = ('',) + key_value[1:]
                elif isinstance(key_value, str):
                    item_to_replace = key_value[1:]

                # Если соответствующего элемента нет в оригинале -- пропускаем.
                if item_to_replace not in original.keys():
                    continue

                # Если секция для замены в шаблоне пустая -- удаляем
                # соответствующую секцию.
                if isinstance(template[key_value], dict) and\
                   template[key_value] == OrderedDict():
                    original.pop(item_to_replace)
                    continue

                # Если символ замены стоит перед параметром, а не перед
                # секцией -- просто заменяем значение параметра.
                if not isinstance(template[key_value], dict):
                    original[item_to_replace] = template[key_value]
                    continue

                # Если обработка комментариев включена -- сохраняем
                # комментарии к заменяемой секции.
                if self._comments_processing:
                    if '#' in original[item_to_replace]:
                        replacement = OrderedDict({'#':
                                                   original[item_to_replace]
                                                   ['#']}
                                                  )
                        # накладываем словарь шаблона на пустой словарь, чтобы
                        # выполнить все управляющие элементы, которые
                        # могут туда попасть.
                        self._join(replacement,
                                   template[key_value],
                                   self._join_before_in_areas)
                    else:
                        replacement = OrderedDict()
                        self._join(replacement,
                                   template[key_value],
                                   self._join_before_in_areas)

                    # Если после наложения шаблона словарь замены оказался
                    # пустым -- удаляем соотвествующий элемент в оригинале.
                    if (replacement == OrderedDict() or
                            replacement.keys() == {'#'}):
                        del(original[item_to_replace])
                    else:
                        original[item_to_replace] = replacement
                else:
                    original[item_to_replace] = OrderedDict()
                    self._join(original[item_to_replace],
                               template[key_value],
                               self._join_before_in_areas)

                    if (original[item_to_replace] == OrderedDict() or
                            original[item_to_replace].keys() == {'#'}):
                        del(original[item_to_replace])

            elif key_value not in original.keys():
                if isinstance(template[key_value], dict):
                    dictionary_to_add = OrderedDict()
                    self._join(dictionary_to_add,
                               template[key_value],
                               self._join_before_in_areas)
                    if dictionary_to_add != OrderedDict():
                        if not join_before:
                            original[key_value] = dictionary_to_add
                        else:
                            forwarded_items[key_value] = dictionary_to_add
                else:
                    if not join_before:
                        original[key_value] = template[key_value]
                    else:
                        forwarded_items[key_value] = template[key_value]
            else:
                if isinstance(original[key_value], dict) and \
                   isinstance(template[key_value], dict):
                    self._join(original[key_value],
                               template[key_value],
                               self._join_before_in_areas)
                else:
                    if self._comments_processing:
                        original[key_value][-1] = template[key_value][-1]
                    else:
                        original[key_value] = template[key_value]
            if join_before:
                for key_value in reversed(forwarded_items.keys()):
                    original[key_value] = forwarded_items[key_value]
                    original.move_to_end(key_value, last=False)

    def make_template(self, template):
        full_diff, set_to_check = self.compare_dictionaries(
                                                  self._document_dictionary,
                                                  template._document_dictionary
                                                           )
        template_object = copy(self)
        template_object._document_dictionary = full_diff
        return template_object

    def compare_dictionaries(self, dict_1, dict_2):
        to_remove_dictionary = OrderedDict()
        to_add_dictionary = OrderedDict()
        to_replace_dictionary = OrderedDict()
        unchanged_set = set()

        to_remove = dict_1.keys() - dict_2.keys()

        if '#' in to_remove:
            to_remove.remove('#')

        for key in dict_1:
            if key in to_remove:
                if isinstance(key, tuple):
                    new_key = ('!', *key[1:])
                else:
                    new_key = '!{}'.format(key)
                if isinstance(dict_1[key], dict):
                    to_remove_dictionary.update({new_key: dict_1[key]})
                else:
                    if self._comments_processing:
                        to_remove_dictionary.update({new_key:
                                                     [dict_1[key][-1]]})
                    else:
                        to_remove_dictionary.update({new_key: dict_1[key]})

        to_add = dict_2.keys() - dict_1.keys()

        if '#' in to_add:
            to_add.remove('#')

        for key in dict_2:
            if key in to_add:
                if isinstance(dict_2[key], dict):
                    section = dict_2[key].copy()
                    if '#' in section:
                        section.remove('#')
                    to_add_dictionary.update({key: section})
                else:
                    if self._comments_processing:
                        to_add_dictionary.update({key: [dict_2[key][-1]]})
                    else:
                        to_add_dictionary.update({key: dict_2[key]})

        intersect = dict_1.keys() & dict_2.keys()
        for key in intersect:
            if (isinstance(dict_1[key], dict) and
                    isinstance(dict_2[key], dict) and
                    dict_1[key] != dict_2[key]):
                diff, set_to_check = self.compare_dictionaries(dict_1[key],
                                                               dict_2[key])
                if set_to_check:
                    to_add_dictionary.update({key: diff})
                else:
                    if isinstance(key, tuple):
                        new_key = ('-', *key[1:])
                    else:
                        new_key = '-{}'.format(key)
                    to_replace_dictionary.update({new_key:
                                                  dict_2[key]})
            elif dict_1[key] != dict_2[key]:
                if self._comments_processing:
                    to_add_dictionary.update({key: [dict_2[key][-1]]})
                else:
                    to_add_dictionary.update({key: dict_2[key]})
            else:
                unchanged_set.add(key)

        full_diff = OrderedDict()
        full_diff.update(**to_remove_dictionary,
                         **to_replace_dictionary,
                         **to_add_dictionary)
        return full_diff, unchanged_set

    @property
    def document_text(self):
        file_loader = PackageLoader('calculate.templates.format',
                                    self.TEMPLATES_DIRECTORY)
        formats_environment = Environment(loader=file_loader,
                                          trim_blocks=True,
                                          lstrip_blocks=True)
        formats_environment.globals.update(zip=zip)
        formats_environment.add_extension('jinja2.ext.do')
        template = formats_environment.get_template(self.FORMAT)
        document_text = template.render(
                                  document_dictionary=self._document_dictionary
                                       )
        return document_text

    def _finish_method(self):
        pass

    def _is_ready_to_update(self):
        is_ready, self._ready_to_update = self._ready_to_update, False
        return is_ready

    def _is_match(self):
        is_match, self._match = self._match, False
        return is_match