|
|
# vim: fileencoding=utf-8
|
|
|
#
|
|
|
from .base_format import BaseFormat
|
|
|
from collections import OrderedDict
|
|
|
import re
|
|
|
try:
|
|
|
from lxml.etree.ElementTree import fromstring
|
|
|
except ImportError:
|
|
|
from xml.etree.ElementTree import fromstring
|
|
|
|
|
|
|
|
|
class PatchFormat(BaseFormat):
|
|
|
def __init__(self, document_text: str, multiline=False, dotall=False):
|
|
|
processing_methods = OrderedDict()
|
|
|
super().__init__(processing_methods)
|
|
|
self._format = 'patch'
|
|
|
|
|
|
self._multiline_flag = multiline
|
|
|
self._dotall_flag = dotall
|
|
|
self._parsed_patch = None
|
|
|
|
|
|
self._document_to_patch = ''
|
|
|
self._FLAG_VALUES = {'True': True,
|
|
|
'False': False,
|
|
|
'true': True,
|
|
|
'false': False,
|
|
|
'1': True,
|
|
|
'0': False}
|
|
|
|
|
|
self._XML_ROOT_LINE = '<?xml version="1.0" encoding="utf-8"?>\
|
|
|
<patch>{0}</patch>'
|
|
|
|
|
|
if not self._parse_patch(document_text):
|
|
|
# Какая-то обработка ошибки.
|
|
|
print('Error: Can not parse patch document.')
|
|
|
|
|
|
def _parse_patch(self, patch_text):
|
|
|
xml_patch = self._XML_ROOT_LINE.format(patch_text.strip())
|
|
|
try:
|
|
|
self._parsed_patch = fromstring(xml_patch)
|
|
|
return True
|
|
|
except Exception:
|
|
|
# Какая-то обработка ошибки.
|
|
|
print('Error: Incorrect text of the template.')
|
|
|
return False
|
|
|
|
|
|
def execute_format(self, document_to_patch):
|
|
|
if not document_to_patch.strip() == '':
|
|
|
self._document_to_patch = document_to_patch
|
|
|
|
|
|
if self._parse_patch is None:
|
|
|
return False
|
|
|
else:
|
|
|
if not self._patch_document(document_to_patch):
|
|
|
error_message = 'Error: Can not run patch.'
|
|
|
print(error_message)
|
|
|
return False
|
|
|
|
|
|
else:
|
|
|
after_patch = self._document_to_patch
|
|
|
self._document_to_patch = ''
|
|
|
return after_patch
|
|
|
|
|
|
def _patch_document(self, document_to_patch):
|
|
|
patch_iterator = self._parsed_patch.getiterator()
|
|
|
PATCH_DOCUMENT_TAGS = ('reg', 'text')
|
|
|
|
|
|
patch_element = next(patch_iterator, False)
|
|
|
|
|
|
if not patch_element or not patch_element.tag == 'patch':
|
|
|
print('Error: Incorrect text of the template.')
|
|
|
return False
|
|
|
|
|
|
while True:
|
|
|
for patch_tag in PATCH_DOCUMENT_TAGS:
|
|
|
patch_element = next(patch_iterator, None)
|
|
|
|
|
|
if patch_element is None:
|
|
|
if patch_tag == 'text':
|
|
|
print('Error: Last <text>Text</text> '
|
|
|
'object is missed.')
|
|
|
return False
|
|
|
else:
|
|
|
break
|
|
|
|
|
|
if patch_element.tag == patch_tag:
|
|
|
if patch_element.text is not None:
|
|
|
element_text = patch_element.text.strip()
|
|
|
if element_text == '':
|
|
|
error_message = 'Error: Incorrect text of the \
|
|
|
template: <{0}>%s</{0}>'.format(
|
|
|
patch_tag
|
|
|
)
|
|
|
print(error_message)
|
|
|
return False
|
|
|
else:
|
|
|
error_message = 'Error: Incorrect text of the \
|
|
|
template: <{0}></{0}>'.format(
|
|
|
patch_tag
|
|
|
)
|
|
|
print(error_message)
|
|
|
return False
|
|
|
|
|
|
if patch_tag == 'reg':
|
|
|
dotall = patch_element.attrib.get('dotall', False)
|
|
|
regex_flags = 0
|
|
|
|
|
|
if 'multiline' in patch_element.attrib:
|
|
|
multiline = patch_element.attrib['multiline']
|
|
|
if multiline not in self._FLAG_VALUES:
|
|
|
error_message = ('Error: Invalid multiline '
|
|
|
'value.')
|
|
|
print(error_message)
|
|
|
return False
|
|
|
else:
|
|
|
multiline = self._FLAG_VALUES[multiline]
|
|
|
|
|
|
# Если глобально флаг MULTILINE включен, но в
|
|
|
# атрибутах тэга <reg> этот флаг присутствует со
|
|
|
# значением False -- для этого регулярного
|
|
|
# выражения этот флаг также будет False.
|
|
|
multiline_global = self._multiline_flag & multiline
|
|
|
else:
|
|
|
multiline = False
|
|
|
multiline_global = self._multiline_flag
|
|
|
|
|
|
if multiline_global or multiline:
|
|
|
regex_flags |= re.MULTILINE
|
|
|
|
|
|
if 'dotall' in patch_element.attrib:
|
|
|
dotall = patch_element.attrib['dotall']
|
|
|
if dotall not in self._FLAG_VALUES:
|
|
|
error_message = 'Error: Invalid dotall value.'
|
|
|
print(error_message)
|
|
|
return False
|
|
|
else:
|
|
|
dotall = self._FLAG_VALUES[dotall]
|
|
|
|
|
|
# Если глобально флаг DOTALL включен, но в
|
|
|
# атрибутах тэга <reg> этот флаг присутствует со
|
|
|
# значением False -- для этого регулярного
|
|
|
# выражения этот флаг также будет False.
|
|
|
dotall_global = self._dotall_flag & dotall
|
|
|
else:
|
|
|
dotall = False
|
|
|
dotall_global = self._dotall_flag
|
|
|
|
|
|
if dotall_global or dotall:
|
|
|
regex_flags |= re.DOTALL
|
|
|
|
|
|
regex_expression = re.compile(element_text,
|
|
|
regex_flags)
|
|
|
else:
|
|
|
text_for_replace = element_text
|
|
|
else:
|
|
|
if patch_element.tag in PATCH_DOCUMENT_TAGS:
|
|
|
error_message = 'Error: <{0}> is expected, \
|
|
|
<{1}> instead.'.format(
|
|
|
patch_tag,
|
|
|
patch_element.tag
|
|
|
)
|
|
|
print(error_message)
|
|
|
else:
|
|
|
error_message = 'Error: Unknown tag: {0}'.format(
|
|
|
patch_element.tag
|
|
|
)
|
|
|
print(error_message)
|
|
|
# Какая-то обработка ошибки.
|
|
|
error_message = 'Error: Incorrect text of the template.'
|
|
|
print(error_message)
|
|
|
return False
|
|
|
else:
|
|
|
self._document_to_patch = re.sub(regex_expression,
|
|
|
text_for_replace,
|
|
|
self._document_to_patch)
|
|
|
continue
|
|
|
return True
|
