245 lines
11 KiB
Python
245 lines
11 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
|
||
|
|
import re
|
||
|
|
from bs4 import formatter, BeautifulSoup as bs
|
||
|
|
from pathlib import Path
|
||
|
|
|
||
|
|
xml_4indent_formatter = formatter.XMLFormatter(indent=4)
|
||
|
|
NEW_ATTRS = {'required', 'invisible', 'readonly', 'column_invisible'}
|
||
|
|
percent_d_regex = re.compile("%\('?\"?[\w\.\d_]+'?\"?\)d")
|
||
|
|
|
||
|
|
def get_files_recursive(path):
|
||
|
|
return (str(p) for p in Path(path).glob('**/*.xml') if p.is_file())
|
||
|
|
|
||
|
|
root_dir = input('Enter root directory to check (empty for current directory) : ')
|
||
|
|
root_dir = root_dir or '.'
|
||
|
|
all_xml_files = get_files_recursive(root_dir)
|
||
|
|
|
||
|
|
def normalize_domain(domain):
|
||
|
|
"""Normalize Domain, taken from odoo/osv/expression.py -> just the part so that & operators are added where needed.
|
||
|
|
After that, we can use a part of the def parse() from the same file to manage parenthesis for and/or"""
|
||
|
|
if len(domain) == 1:
|
||
|
|
return domain
|
||
|
|
result = []
|
||
|
|
expected = 1 # expected number of expressions
|
||
|
|
op_arity = {'!': 1, '&': 2, '|': 2}
|
||
|
|
for token in domain:
|
||
|
|
if expected == 0: # more than expected, like in [A, B]
|
||
|
|
result[0:0] = ['&'] # put an extra '&' in front
|
||
|
|
expected = 1
|
||
|
|
if isinstance(token, (list, tuple)): # domain term
|
||
|
|
expected -= 1
|
||
|
|
token = tuple(token)
|
||
|
|
else:
|
||
|
|
expected += op_arity.get(token, 0) - 1
|
||
|
|
result.append(token)
|
||
|
|
return result
|
||
|
|
|
||
|
|
def stringify_leaf(leaf):
|
||
|
|
stringify = ''
|
||
|
|
switcher = False
|
||
|
|
# Replace operators not supported in python (=, like, ilike)
|
||
|
|
operator = str(leaf[1])
|
||
|
|
if operator == '=':
|
||
|
|
operator = '=='
|
||
|
|
elif 'like' in operator:
|
||
|
|
if 'not' in operator:
|
||
|
|
operator = 'not in'
|
||
|
|
else:
|
||
|
|
operator = 'in'
|
||
|
|
switcher = True
|
||
|
|
# Take left operand, never to add quotes (should be python object / field)
|
||
|
|
left_operand = leaf[0]
|
||
|
|
# Take care of right operand, don't add quotes if it's list/tuple/set/boolean/number, check if we have a true/false/1/0 string tho.
|
||
|
|
right_operand = leaf[2]
|
||
|
|
if right_operand in ('True', 'False', '1', '0') or type(right_operand) in (list, tuple, set, int, float, bool):
|
||
|
|
right_operand = str(right_operand)
|
||
|
|
else:
|
||
|
|
right_operand = "'"+right_operand+"'"
|
||
|
|
stringify = "%s %s %s" % (right_operand if switcher else left_operand, operator, left_operand if switcher else right_operand)
|
||
|
|
return stringify
|
||
|
|
|
||
|
|
def stringify_attr(stack):
|
||
|
|
if stack in (True, False, 'True', 'False', 1, 0, '1', '0'):
|
||
|
|
return stack
|
||
|
|
last_parenthesis_index = max(index for index, item in enumerate(stack[::-1]) if item not in ('|', '!'))
|
||
|
|
stack = normalize_domain(stack)
|
||
|
|
stack = stack[::-1]
|
||
|
|
result = []
|
||
|
|
for index, leaf_or_operator in enumerate(stack):
|
||
|
|
if leaf_or_operator == '!':
|
||
|
|
expr = result.pop()
|
||
|
|
result.append('(not (%s))' % expr)
|
||
|
|
elif leaf_or_operator == '&' or leaf_or_operator == '|':
|
||
|
|
left = result.pop()
|
||
|
|
# In case of a single | or single & , we expect that it's a tag that have an attribute AND a state
|
||
|
|
# the state will be added as OR in states management
|
||
|
|
try:
|
||
|
|
right = result.pop()
|
||
|
|
except IndexError:
|
||
|
|
res = left + ('%s' % ' and' if leaf_or_operator=='&' else ' or')
|
||
|
|
result.append(res)
|
||
|
|
continue
|
||
|
|
form = '(%s %s %s)'
|
||
|
|
if index > last_parenthesis_index:
|
||
|
|
form = '%s %s %s'
|
||
|
|
result.append(form % (left, 'and' if leaf_or_operator=='&' else 'or', right))
|
||
|
|
else:
|
||
|
|
result.append(stringify_leaf(leaf_or_operator))
|
||
|
|
result = result[0]
|
||
|
|
return result
|
||
|
|
|
||
|
|
def get_new_attrs(attrs):
|
||
|
|
new_attrs = {}
|
||
|
|
attrs_dict = eval(attrs.strip())
|
||
|
|
for attr in NEW_ATTRS:
|
||
|
|
if attr in attrs_dict.keys():
|
||
|
|
new_attrs[attr] = stringify_attr(attrs_dict[attr])
|
||
|
|
ordered_attrs = {attr: new_attrs[attr] for attr in NEW_ATTRS if attr in new_attrs}
|
||
|
|
return ordered_attrs
|
||
|
|
|
||
|
|
# Prettify puts <attribute> on three lines (1/ opening tag, 2/ text, 3/ closing tag), not very cool.
|
||
|
|
# Taken from https://stackoverflow.com/questions/55962146/remove-line-breaks-and-spaces-around-span-elements-with-python-regex
|
||
|
|
# And changed to avoid putting ALL one line, and only manage <attribute>, as it's the only one messing stuff here
|
||
|
|
# Kinda ugly to use the 3 types of tags but tbh I keep it like this while I have no time for a regex replace keeping the name="x" :p
|
||
|
|
def prettify_output(html):
|
||
|
|
for attr in NEW_ATTRS:
|
||
|
|
html = re.sub(f'<attribute name="{attr}">[ \n]+',f'<attribute name="{attr}">', html)
|
||
|
|
html = re.sub(f'[ \n]+</attribute>',f'</attribute>', html)
|
||
|
|
html = re.sub(r'<field name="([a-z_]+)">[ \n]+', r'<field name="\1">', html)
|
||
|
|
html = re.sub(r'[ \n]+</field>', r'</field>', html)
|
||
|
|
return html
|
||
|
|
|
||
|
|
autoreplace = input('Do you want to auto-replace attributes ? (y/n) (empty == no) (will not ask confirmation for each file) : ') or 'n'
|
||
|
|
nofilesfound = True
|
||
|
|
ok_files = []
|
||
|
|
nok_files = []
|
||
|
|
|
||
|
|
for xml_file in all_xml_files:
|
||
|
|
try:
|
||
|
|
with open(xml_file, 'rb') as f:
|
||
|
|
contents = f.read().decode('utf-8')
|
||
|
|
f.close()
|
||
|
|
if not 'attrs' in contents and not 'states' in contents:
|
||
|
|
continue
|
||
|
|
counter_for_percent_d_replace = 1
|
||
|
|
percent_d_results = {}
|
||
|
|
for percent_d in percent_d_regex.findall(contents):
|
||
|
|
contents = contents.replace(percent_d, "'REPLACEME%s'" % counter_for_percent_d_replace)
|
||
|
|
percent_d_results[counter_for_percent_d_replace] = percent_d
|
||
|
|
counter_for_percent_d_replace += 1
|
||
|
|
soup = bs(contents, 'xml')
|
||
|
|
tags_with_attrs = soup.select('[attrs]')
|
||
|
|
attribute_tags_name_attrs = soup.select('attribute[name="attrs"]')
|
||
|
|
tags_with_states = soup.select('[states]')
|
||
|
|
attribute_tags_name_states = soup.select('attribute[name="states"]')
|
||
|
|
if not (tags_with_attrs or attribute_tags_name_attrs or\
|
||
|
|
tags_with_states or attribute_tags_name_states):
|
||
|
|
continue
|
||
|
|
print('\n################################################################')
|
||
|
|
print('##### Taking care of file -> %s' % xml_file)
|
||
|
|
print('\n########### Current tags found ###\n')
|
||
|
|
for t in tags_with_attrs + attribute_tags_name_attrs + tags_with_states + attribute_tags_name_states:
|
||
|
|
print(t)
|
||
|
|
|
||
|
|
nofilesfound = False
|
||
|
|
# Management of tags that have attrs=""
|
||
|
|
for tag in tags_with_attrs:
|
||
|
|
attrs = tag['attrs']
|
||
|
|
new_attrs = get_new_attrs(attrs)
|
||
|
|
del tag['attrs']
|
||
|
|
for new_attr in new_attrs.keys():
|
||
|
|
tag[new_attr] = new_attrs[new_attr]
|
||
|
|
# Management of attributes name="attrs"
|
||
|
|
attribute_tags_after = []
|
||
|
|
for attribute_tag in attribute_tags_name_attrs:
|
||
|
|
new_attrs = get_new_attrs(attribute_tag.text)
|
||
|
|
for new_attr in new_attrs.keys():
|
||
|
|
new_tag = soup.new_tag('attribute')
|
||
|
|
new_tag['name'] = new_attr
|
||
|
|
new_tag.append(str(new_attrs[new_attr]))
|
||
|
|
attribute_tags_after.append(new_tag)
|
||
|
|
attribute_tag.insert_after(new_tag)
|
||
|
|
attribute_tag.decompose()
|
||
|
|
# Management ot tags that have states=""
|
||
|
|
for state_tag in tags_with_states:
|
||
|
|
base_invisible = ''
|
||
|
|
if 'invisible' in state_tag.attrs and state_tag['invisible']:
|
||
|
|
base_invisible = state_tag['invisible']
|
||
|
|
if not (base_invisible.endswith('or') or base_invisible.endswith('and')):
|
||
|
|
base_invisible = base_invisible + ' or '
|
||
|
|
else:
|
||
|
|
base_invisible = base_invisible + ' '
|
||
|
|
invisible_attr = "state not in [%s]" % ','.join(("'" + state.strip() + "'") for state in state_tag['states'].split(','))
|
||
|
|
state_tag['invisible'] = base_invisible + invisible_attr
|
||
|
|
del state_tag['states']
|
||
|
|
# Management of attributes name="states"
|
||
|
|
attribute_tags_states_after = []
|
||
|
|
for attribute_tag_states in attribute_tags_name_states:
|
||
|
|
states = attribute_tag_states.text
|
||
|
|
existing_invisible_tag = False
|
||
|
|
# I don't know why, looking for attribute[name="invisible"] does not work,
|
||
|
|
# but if it exists, I can find it with findAll attribute -> loop to name="invisible"
|
||
|
|
for tag in attribute_tag_states.parent.findAll('attribute'):
|
||
|
|
if tag['name'] == 'invisible':
|
||
|
|
existing_invisible_tag = tag
|
||
|
|
break
|
||
|
|
if not existing_invisible_tag:
|
||
|
|
existing_invisible_tag = soup.new_tag('attribute')
|
||
|
|
existing_invisible_tag['name'] = 'invisible'
|
||
|
|
if existing_invisible_tag.text:
|
||
|
|
states_to_add = 'state not in [%s]' % (
|
||
|
|
','.join(("'" + state.strip() + "'") for state in states.split(','))
|
||
|
|
)
|
||
|
|
if existing_invisible_tag.text.endswith('or') or existing_invisible_tag.text.endswith('and'):
|
||
|
|
new_invisible_text = '%s %s' % (existing_invisible_tag.text, states_to_add)
|
||
|
|
else:
|
||
|
|
new_invisible_text = ' or '.join([existing_invisible_tag.text, states_to_add])
|
||
|
|
else:
|
||
|
|
new_invisible_text = 'state not in [%s]' % (
|
||
|
|
','.join(("'" + state.strip() + "'") for state in states.split(','))
|
||
|
|
)
|
||
|
|
existing_invisible_tag.string = new_invisible_text
|
||
|
|
attribute_tag_states.insert_after(existing_invisible_tag)
|
||
|
|
attribute_tag_states.decompose()
|
||
|
|
attribute_tags_states_after.append(existing_invisible_tag)
|
||
|
|
|
||
|
|
print('\n########### Will be replaced by ###\n')
|
||
|
|
for t in tags_with_attrs + attribute_tags_after + tags_with_states + attribute_tags_states_after:
|
||
|
|
print(t)
|
||
|
|
print('################################################################\n')
|
||
|
|
if autoreplace.lower()[0] == 'n':
|
||
|
|
confirm = input('Do you want to replace? (y/n) (empty == no) : ') or 'n'
|
||
|
|
else:
|
||
|
|
confirm = 'y'
|
||
|
|
if confirm.lower()[0] == 'y':
|
||
|
|
with open(xml_file, 'wb') as rf:
|
||
|
|
html = soup.prettify(formatter=xml_4indent_formatter)
|
||
|
|
html = prettify_output(html)
|
||
|
|
for percent_d_result in percent_d_results.keys():
|
||
|
|
html = html.replace("'REPLACEME%s'" % percent_d_result, percent_d_results[percent_d_result])
|
||
|
|
rf.write(html.encode('utf-8'))
|
||
|
|
ok_files.append(xml_file)
|
||
|
|
except Exception as e:
|
||
|
|
nok_files.append((xml_file, e))
|
||
|
|
|
||
|
|
print('\n################################################')
|
||
|
|
print('################## Run Debug ##################')
|
||
|
|
print('################################################')
|
||
|
|
|
||
|
|
if nofilesfound:
|
||
|
|
print('No XML Files with "attrs" or "states" found in dir " %s "' % root_dir)
|
||
|
|
|
||
|
|
print('Succeeded on files')
|
||
|
|
for file in ok_files:
|
||
|
|
print(file)
|
||
|
|
if not ok_files:
|
||
|
|
print('No files')
|
||
|
|
print('')
|
||
|
|
print('Failed on files')
|
||
|
|
for file in nok_files:
|
||
|
|
print(file[0])
|
||
|
|
print('Reason: ', file[1])
|
||
|
|
if not nok_files:
|
||
|
|
print('No files')
|