Source Code for Module translate.storage.placeables.lisa

  1  #!/usr/bin/env python 
  2  # -*- coding: utf-8 -*- 
  3  # 
  4  # Copyright 2008-2009 Zuza Software Foundation 
  5  # 
  6  # This file is part of the Translate Toolkit. 
  7  # 
  8  # This program is free software; you can redistribute it and/or modify 
  9  # it under the terms of the GNU General Public License as published by 
 10  # the Free Software Foundation; either version 2 of the License, or 
 11  # (at your option) any later version. 
 12  # 
 13  # This program is distributed in the hope that it will be useful, 
 14  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 15  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 16  # GNU General Public License for more details. 
 17  # 
 18  # You should have received a copy of the GNU General Public License 
 19  # along with this program; if not, see <http://www.gnu.org/licenses/>. 
 20   
 21  from lxml import etree 
 22   
 23  from translate.misc.xml_helpers import * 
 24  from translate.storage.placeables import base, xliff, StringElem 
 25  from translate.storage.xml_extract import misc 
 26   
 27  __all__ = ['xml_to_strelem', 'strelem_to_xml'] 
 28  # Use the above functions as entry points into this module. The rest are used by these functions. 
 29   
 30   
 31 -def make_empty_replacement_placeable(klass, node, xml_space="preserve"): 
 32      try: 
 33          return klass( 
 34              id=node.attrib[u'id'], 
 35              rid=node.attrib.get('rid', None), 
 36              xid=node.attrib.get('xid', None), 
 37              xml_attrib=node.attrib 
 38          ) 
 39      except KeyError: 
 40          pass 
 41      return klass() 
 42   
 43 -def make_g_placeable(klass, node, xml_space="default"): 
 44      return klass( 
 45          id=node.attrib[u'id'], 
 46          sub=xml_to_strelem(node, xml_space).sub, 
 47          xml_attrib=node.attrib 
 48      ) 
 49   
 50 -def not_yet_implemented(klass, node, xml_space="preserve"): 
 51      raise NotImplementedError 
 52   
 53 -def make_unknown(klass, node, xml_space="preserve"): 
 54      assert klass is xliff.UnknownXML 
 55   
 56      sub = xml_to_strelem(node, xml_space).sub 
 57      id =  node.get('id',  None) 
 58      rid = node.get('rid', None) 
 59      xid = node.get('xid', None) 
 60   
 61      return klass(sub=sub, id=id, rid=rid, xid=xid, xml_node=node) 
 62   
 63  _class_dictionary = { 
 64      #u'bpt': (xliff.Bpt, not_yet_implemented), 
 65      u'bx' : (xliff.Bx,  make_empty_replacement_placeable), 
 66      #u'ept': (xliff.Ept, not_yet_implemented), 
 67      u'ex' : (xliff.Ex,  make_empty_replacement_placeable), 
 68      u'g'  : (xliff.G,   make_g_placeable), 
 69      #u'it' : (xliff.It,  not_yet_implemented), 
 70      #u'ph' : (xliff.Ph,  not_yet_implemented), 
 71      #u'sub': (xliff.Sub, not_yet_implemented), 
 72      u'x'  : (xliff.X,   make_empty_replacement_placeable) 
 73  } 
 74   
 75 -def make_placeable(node, xml_space): 
 76      _namespace, tag = misc.parse_tag(node.tag) 
 77      if tag in _class_dictionary: 
 78          klass, maker = _class_dictionary[tag] 
 79      else: 
 80          klass, maker = xliff.UnknownXML, make_unknown 
 81      return maker(klass, node, xml_space) 
 82   
 83 -def as_unicode(string): 
 84      if isinstance(string, unicode): 
 85          return string 
 86      elif isinstance(string, StringElem): 
 87          return unicode(string) 
 88      else: 
 89          return unicode(string.decode('utf-8')) 
 90   
 91 -def xml_to_strelem(dom_node, xml_space="preserve"): 
 92      if dom_node is None: 
 93          return StringElem() 
 94      if isinstance(dom_node, basestring): 
 95          dom_node = etree.fromstring(dom_node) 
 96      normalize_xml_space(dom_node, xml_space, remove_start=True) 
 97      result = StringElem() 
 98      if dom_node.text: 
 99          result.sub.append(StringElem(unicode(dom_node.text))) 
100      for child_dom_node in dom_node: 
101          result.sub.append(make_placeable(child_dom_node, xml_space)) 
102          if child_dom_node.tail: 
103              result.sub.append(StringElem(unicode(child_dom_node.tail))) 
104      result.prune() 
105      return result 
106   
107  # ========================================================== 
108   
109 -def placeable_as_dom_node(placeable, tagname): 
110      dom_node = etree.Element(tagname) 
111      if placeable.id is not None: 
112          dom_node.attrib['id'] = placeable.id 
113      if placeable.xid is not None: 
114          dom_node.attrib['xid'] = placeable.xid 
115      if placeable.rid is not None: 
116          dom_node.attrib['rid'] = placeable.rid 
117   
118      if hasattr(placeable, 'xml_attrib'): 
119          for attrib, value in placeable.xml_attrib.items(): 
120              dom_node.set(attrib, value) 
121   
122      return dom_node 
123   
124 -def unknown_placeable_as_dom_node(placeable): 
125      assert type(placeable) is xliff.UnknownXML 
126   
127      from copy import copy 
128      node = copy(placeable.xml_node) 
129      for i in range(len(node)): 
130          del node[0] 
131      node.tail = None 
132      node.text = None 
133   
134      return node 
135   
136  _placeable_dictionary = { 
137      xliff.Bpt: lambda placeable: placeable_as_dom_node(placeable, 'bpt'), 
138      xliff.Bx : lambda placeable: placeable_as_dom_node(placeable, 'bx'), 
139      xliff.Ept: lambda placeable: placeable_as_dom_node(placeable, 'ept'), 
140      xliff.Ex : lambda placeable: placeable_as_dom_node(placeable, 'ex'), 
141      xliff.G  : lambda placeable: placeable_as_dom_node(placeable, 'g'), 
142      xliff.It : lambda placeable: placeable_as_dom_node(placeable, 'it'), 
143      xliff.Ph : lambda placeable: placeable_as_dom_node(placeable, 'ph'), 
144      xliff.Sub: lambda placeable: placeable_as_dom_node(placeable, 'sub'), 
145      xliff.X  : lambda placeable: placeable_as_dom_node(placeable, 'x'), 
146      xliff.UnknownXML: unknown_placeable_as_dom_node, 
147      base.Bpt:  lambda placeable: placeable_as_dom_node(placeable, 'bpt'), 
148      base.Bx :  lambda placeable: placeable_as_dom_node(placeable, 'bx'), 
149      base.Ept:  lambda placeable: placeable_as_dom_node(placeable, 'ept'), 
150      base.Ex :  lambda placeable: placeable_as_dom_node(placeable, 'ex'), 
151      base.G  :  lambda placeable: placeable_as_dom_node(placeable, 'g'), 
152      base.It :  lambda placeable: placeable_as_dom_node(placeable, 'it'), 
153      base.Ph :  lambda placeable: placeable_as_dom_node(placeable, 'ph'), 
154      base.Sub:  lambda placeable: placeable_as_dom_node(placeable, 'sub'), 
155      base.X  :  lambda placeable: placeable_as_dom_node(placeable, 'x') 
156  } 
157   
158 -def xml_append_string(node, string): 
159      if not len(node): 
160          if not node.text: 
161              node.text = unicode(string) 
162          else: 
163              node.text += unicode(string) 
164      else: 
165          lastchild = node.getchildren()[-1] 
166          if lastchild.tail is None: 
167              lastchild.tail = '' 
168          lastchild.tail += unicode(string) 
169      return node 
170   
171 -def strelem_to_xml(parent_node, elem): 
172      if isinstance(elem, (str, unicode)): 
173          return xml_append_string(parent_node, elem) 
174      if not isinstance(elem, StringElem): 
175          return parent_node 
176   
177      if type(elem) is StringElem and elem.isleaf(): 
178          return xml_append_string(parent_node, elem) 
179   
180      if elem.__class__ in _placeable_dictionary: 
181          node = _placeable_dictionary[elem.__class__](elem) 
182          parent_node.append(node) 
183      else: 
184          node = parent_node 
185   
186      for sub in elem.sub: 
187          strelem_to_xml(node, sub) 
188   
189      return parent_node 
190   
191   
192 -def parse_xliff(pstr): 
193      try: 
194          return xml_to_strelem(etree.fromstring('<source>%s</source>' % (pstr))) 
195      except Exception, exc: 
196          raise 
197          return None 
198  xliff.parsers = [parse_xliff] 
199