348 lines
11 KiB
Python
348 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
##############################################################################
|
|
#
|
|
# OpenERP, Open Source Management Solution
|
|
# Copyright (C) 2004-2010 OpenERP SA (<http://openerp.com>).
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
|
|
"""
|
|
Experimental script for conversion between OpenERP's XML serialization format
|
|
and the new YAML serialization format introduced in OpenERP 6.0.
|
|
Intended to be used as a quick preprocessor for converting data/test files, then
|
|
to be fine-tuned manually.
|
|
"""
|
|
|
|
import yaml
|
|
import logging
|
|
from lxml import etree
|
|
|
|
__VERSION__ = '0.0.2'
|
|
|
|
def toString(value):
|
|
value='"' + value + '"'
|
|
return value
|
|
|
|
class XmlTag(etree.ElementBase):
|
|
def _to_yaml(self):
|
|
child_tags = []
|
|
for node in self:
|
|
if hasattr(node, '_to_yaml'):
|
|
child_tags.append(node._to_yaml())
|
|
return self.tag(attrib=self.attrib, child_tags=child_tags)
|
|
|
|
class YamlTag(object):
|
|
"""
|
|
Superclass for constructors of custom tags defined in yaml file.
|
|
"""
|
|
def __init__(self, **kwargs):
|
|
self.__dict__.update(kwargs)
|
|
self.attrib = self.__dict__.get('attrib', {})
|
|
self.child_tags = self.__dict__.get('child_tags', '')
|
|
def __getitem__(self, key):
|
|
return getattr(self, key)
|
|
def __getattr__(self, attr):
|
|
return None
|
|
def __repr__(self):
|
|
for k,v in self.attrib.iteritems():
|
|
if str(v) and str(v)[0] in ['[', '{', '#', '*', '(']:
|
|
self.attrib[k] = toString(self.attrib[k]).replace("'", '')
|
|
st = self.yaml_tag + ' ' + str(self.attrib)
|
|
return st
|
|
|
|
# attrib tags
|
|
class ref(YamlTag):
|
|
yaml_tag = u'!ref'
|
|
def __init__(self, expr="False"):
|
|
self.expr = expr
|
|
def __repr__(self):
|
|
return "'%s'"%str(self.expr)
|
|
|
|
class Eval(YamlTag):
|
|
yaml_tag = u'!eval'
|
|
def __init__(self, expr="False"):
|
|
self.expr = expr
|
|
def __repr__(self):
|
|
value=str(self.expr)
|
|
if value.find("6,") != -1:
|
|
value = eval(str(eval(value)))
|
|
value=value[0][2]
|
|
value = [[value]]
|
|
else:
|
|
try:
|
|
value=int(value)
|
|
except:
|
|
if value and value[0] in ['[', '{', '#', '*', '(']:
|
|
value = value.replace('"', r'\"')
|
|
value = toString(value)
|
|
else:
|
|
try:
|
|
value = eval(value)
|
|
except Exception:
|
|
pass
|
|
return value
|
|
|
|
class Search(YamlTag):
|
|
yaml_tag = u'!ref'
|
|
|
|
# test tag
|
|
class xml_test(XmlTag):
|
|
def _to_yaml(self):
|
|
expr = self.attrib.get('expr')
|
|
text = self.text
|
|
if text:
|
|
expr = expr + ' == ' + '"%s"'%text
|
|
return [[expr]]
|
|
|
|
class xml_data(etree.ElementBase):
|
|
def _to_yaml(self):
|
|
value = self.attrib.get('noupdate', "0")
|
|
return data(value)
|
|
|
|
# field tag:
|
|
class xml_field(etree.ElementBase):
|
|
def _to_yaml(self):
|
|
field = ' ' + self.attrib.pop('name','unknown')
|
|
|
|
if self.attrib.get('search', None):
|
|
value = Search(attrib=self.attrib, child_tags='').__repr__()
|
|
else:
|
|
attr = (self.attrib.get('ref', None) and 'ref') or (self.attrib.get('eval', None) and 'eval') or 'None'
|
|
value = Eval(self.attrib.get(attr, self.text)).__repr__() or ''
|
|
return {field: value}
|
|
|
|
# value tag
|
|
class xml_value(etree.ElementBase):
|
|
def _to_yaml(self):
|
|
|
|
if self.attrib.get('eval', None):
|
|
key, val = 'eval', '"'+self.attrib.get('eval')+'"'
|
|
elif self.attrib.get('model', None):
|
|
key, val = 'model', self.attrib.get('model')
|
|
val=val.replace("'",'""')
|
|
self.attrib.pop(key)
|
|
d={}
|
|
for k,v in self.attrib.iteritems():
|
|
if k == 'search':
|
|
v = '"' + v + '"'
|
|
k='--' + k
|
|
v=v.replace("'",'""')
|
|
d[k] = v
|
|
if d:
|
|
ls=[[{key:val},dict(d)]]
|
|
else:
|
|
ls=[[{key:val}]]
|
|
return ls
|
|
|
|
# data tag
|
|
class data(YamlTag):
|
|
yaml_tag = u'!context'
|
|
def __init__(self, noupdate="0"):
|
|
self.child_tags = {' noupdate':noupdate}
|
|
def __repr__(self):
|
|
return "!!context"
|
|
|
|
# Record tag
|
|
class Record(YamlTag):
|
|
yaml_tag = u'!record'
|
|
class xml_record(XmlTag):
|
|
tag=Record
|
|
def _to_yaml(self):
|
|
child_tags = {}
|
|
for node in self:
|
|
if hasattr(node, '_to_yaml'):
|
|
child_tags.update(node._to_yaml())
|
|
return Record(attrib=self.attrib, child_tags=child_tags)
|
|
|
|
# ir_set tag
|
|
class Ir_Set(YamlTag):
|
|
yaml_tag = u'!ir_set'
|
|
def __repr__(self):
|
|
st = self.yaml_tag
|
|
return st
|
|
class xml_ir_set(XmlTag):
|
|
tag=Ir_Set
|
|
def _to_yaml(self):
|
|
child_tags = {}
|
|
for node in self:
|
|
if hasattr(node, '_to_yaml'):
|
|
child_tags.update(node._to_yaml())
|
|
return Ir_Set(attrib=self.attrib, child_tags=child_tags)
|
|
|
|
# workflow tag
|
|
class Workflow(YamlTag):
|
|
yaml_tag = u'!workflow'
|
|
class xml_workflow(XmlTag):
|
|
tag=Workflow
|
|
|
|
# function tag
|
|
class Function(YamlTag):
|
|
yaml_tag = u'!function'
|
|
class xml_function(XmlTag):
|
|
tag=Function
|
|
|
|
# function tag
|
|
class Assert(YamlTag):
|
|
yaml_tag = u'!assert'
|
|
class xml_assert(XmlTag):
|
|
tag=Assert
|
|
|
|
# menuitem tagresult.append(yaml.safe_dump(obj, default_flow_style=False, allow_unicode=True).replace("'",''))
|
|
class MenuItem(YamlTag):
|
|
yaml_tag = u'!menuitem'
|
|
class xml_menuitem(XmlTag):
|
|
tag=MenuItem
|
|
|
|
# act_window tag
|
|
class ActWindow(YamlTag):
|
|
yaml_tag = u'!act_window'
|
|
class xml_act_window(XmlTag):
|
|
tag=ActWindow
|
|
|
|
# report tag
|
|
class Report(YamlTag):
|
|
yaml_tag = u'!report'
|
|
class xml_report(XmlTag):
|
|
tag=Report
|
|
|
|
# deletes tag
|
|
class Delete(YamlTag):
|
|
yaml_tag = u'!delete'
|
|
class xml_delete(XmlTag):
|
|
tag=Delete
|
|
|
|
# python tag
|
|
class Python(YamlTag):
|
|
yaml_tag = u'!python'
|
|
class xml_python(XmlTag):
|
|
tag=Python
|
|
|
|
# context tag
|
|
class Context(YamlTag):
|
|
yaml_tag = u'!context'
|
|
class xml_context(XmlTag):
|
|
tag=Context
|
|
|
|
# url tag
|
|
class Url(YamlTag):
|
|
yaml_tag = u'!url'
|
|
class xml_url(XmlTag):
|
|
tag=Url
|
|
|
|
# delete tag
|
|
class Delete(YamlTag):
|
|
yaml_tag = u'!delete'
|
|
class xml_delete(XmlTag):
|
|
tag=Delete
|
|
|
|
def represent_data(dumper, data):
|
|
return dumper.represent_mapping(u'tag:yaml.org,2002:map', [('!'+str(data), data.child_tags)])
|
|
|
|
yaml.SafeDumper.add_representer(Record, represent_data)
|
|
yaml.SafeDumper.add_representer(data, represent_data)
|
|
yaml.SafeDumper.add_representer(Workflow, represent_data)
|
|
yaml.SafeDumper.add_representer(Function, represent_data)
|
|
yaml.SafeDumper.add_representer(Assert, represent_data)
|
|
yaml.SafeDumper.add_representer(MenuItem, represent_data)
|
|
yaml.SafeDumper.add_representer(Ir_Set, represent_data)
|
|
yaml.SafeDumper.add_representer(Python, represent_data)
|
|
yaml.SafeDumper.add_representer(Context, represent_data)
|
|
|
|
class MyLookup(etree.CustomElementClassLookup):
|
|
def lookup(self, node_type, document, namespace, name):
|
|
if node_type=='element':
|
|
return {
|
|
'data': xml_data,
|
|
'record': xml_record,
|
|
'field': xml_field,
|
|
'workflow': xml_workflow,
|
|
'function': xml_function,
|
|
'value': xml_value,
|
|
'assert': xml_assert,
|
|
'test': xml_test,
|
|
'menuitem': xml_menuitem,
|
|
'act_window': xml_act_window,
|
|
'report': xml_report,
|
|
'delete': xml_delete,
|
|
'python': xml_python,
|
|
'context': xml_context,
|
|
'url': xml_url,
|
|
'ir_set': xml_ir_set,
|
|
}.get(name, None)
|
|
elif node_type=='comment':
|
|
return None#xml_comment
|
|
return None
|
|
|
|
class xml_parse(object):
|
|
def __init__(self):
|
|
self.context = {}
|
|
def parse(self, fname):
|
|
parser = etree.XMLParser()
|
|
parser.setElementClassLookup(MyLookup())
|
|
result = []
|
|
self.root = etree.XML(file(fname).read(), parser)
|
|
for data in self.root:
|
|
if hasattr(data, '_to_yaml'):
|
|
obj = data._to_yaml()
|
|
if obj.yaml_tag == '!context':
|
|
result.append(yaml.dump(str(obj)).replace("'",'').split('\n')[0])
|
|
result.append(yaml.dump(obj.child_tags, default_flow_style=False).replace("'",''))
|
|
else:
|
|
result.append(yaml.safe_dump(obj, default_flow_style=False, allow_unicode=True).replace("'",''))
|
|
self.context.update(data.attrib)
|
|
for tag in data:
|
|
if tag.tag == etree.Comment:
|
|
result.append(tag)
|
|
else:
|
|
if hasattr(tag, '_to_yaml'):
|
|
obj = tag._to_yaml()
|
|
if not obj.child_tags:
|
|
result.append(yaml.dump('!'+str(obj), default_flow_style=False, allow_unicode=True, width=999).replace("'",''))
|
|
else:
|
|
result.append(yaml.safe_dump(obj, default_flow_style=False, allow_unicode=True, width=999).replace('\n:', ':\n').replace("'",''))
|
|
print "# Experimental OpenERP xml-to-yml conversion! (v%s)"%__VERSION__
|
|
print "# Please use this as a first conversion/preprocessing step,"
|
|
print "# not as a production-ready tool!"
|
|
for record in result:
|
|
if type(record) != type(''):
|
|
record=str(record)
|
|
l= record.split("\n")
|
|
for line in l:
|
|
print '#' + str(line)
|
|
continue
|
|
record=str(record)
|
|
record = record.replace('- --',' ') #for value tag
|
|
record = record.replace('!!', '- \n !') #for all parent tags
|
|
record = record.replace('- - -', ' -') #for many2many fields
|
|
record = record.replace('? ', '') #for long expressions
|
|
record = record.replace('""', "'") #for string-value under value tag
|
|
print record
|
|
|
|
if __name__=='__main__':
|
|
import optparse
|
|
import sys
|
|
parser = optparse.OptionParser(
|
|
usage = '%s file.xml' % sys.argv[0])
|
|
(opt, args) = parser.parse_args()
|
|
if len(args) != 1:
|
|
parser.error("incorrect number of arguments")
|
|
fname = sys.argv[1]
|
|
p = xml_parse()
|
|
p.parse(fname)
|
|
|
|
|
|
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|