Package translate :: Package storage :: Package placeables :: Module strelem
[hide private]
[frames] | no frames]

Source Code for Module translate.storage.placeables.strelem

  1  #!/usr/bin/env python 
  2  # -*- coding: utf-8 -*- 
  3  # 
  4  # Copyright 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  """ 
 22  Contains the base L{StringElem} class that represents a node in a parsed rich- 
 23  string tree. It is the base class of all placeables. 
 24  """ 
 25   
 26  import logging 
 27  import sys 
28 29 30 -class ElementNotFoundError(ValueError):
31 pass
32
33 34 -class StringElem(object):
35 """ 36 This class represents a sub-tree of a string parsed into a rich structure. 37 It is also the base class of all placeables. 38 """ 39 40 renderer = None 41 """An optional function that returns the Unicode representation of the string.""" 42 sub = [] 43 """The sub-elements that make up this this string.""" 44 has_content = True 45 """Whether this string can have sub-elements.""" 46 iseditable = True 47 """Whether this string should be changable by the user. Not used at the moment.""" 48 isfragile = False 49 """Whether this element should be deleted in its entirety when partially 50 deleted. Only checked when C{iseditable = False}""" 51 istranslatable = True 52 """Whether this string is translatable into other languages.""" 53 isvisible = True 54 """Whether this string should be visible to the user. Not used at the moment.""" 55 56 # INITIALIZERS #
57 - def __init__(self, sub=None, id=None, rid=None, xid=None, **kwargs):
58 if sub is None: 59 sub = [] 60 if isinstance(sub, (unicode, StringElem)): 61 sub = [sub] 62 63 for elem in sub: 64 if not isinstance(elem, (unicode, StringElem)): 65 raise ValueError(elem) 66 67 self.sub = sub 68 self.id = id 69 self.rid = rid 70 self.xid = xid 71 72 for key, value in kwargs.items(): 73 if hasattr(self, key): 74 raise ValueError('attribute already exists: %s' % (key)) 75 setattr(self, key, value) 76 77 self.prune()
78 79 # SPECIAL METHODS #
80 - def __add__(self, rhs):
81 """Emulate the C{unicode} class.""" 82 return unicode(self) + rhs
83
84 - def __contains__(self, item):
85 """Emulate the C{unicode} class.""" 86 return item in unicode(self)
87
88 - def __eq__(self, rhs):
89 """@returns: C{True} if (and only if) all members as well as sub-trees 90 are equal. False otherwise.""" 91 if not isinstance(rhs, StringElem): 92 return False 93 94 return self.id == rhs.id and \ 95 self.iseditable == rhs.iseditable and \ 96 self.istranslatable == rhs.istranslatable and \ 97 self.isvisible == rhs.isvisible and \ 98 self.rid == rhs.rid and \ 99 self.xid == rhs.xid and \ 100 len(self.sub) == len(rhs.sub) and \ 101 not [i for i in range(len(self.sub)) if self.sub[i] != rhs.sub[i]]
102
103 - def __ge__(self, rhs):
104 """Emulate the C{unicode} class.""" 105 return unicode(self) >= rhs
106
107 - def __getitem__(self, i):
108 """Emulate the C{unicode} class.""" 109 return unicode(self)[i]
110
111 - def __getslice__(self, i, j):
112 """Emulate the C{unicode} class.""" 113 return unicode(self)[i:j]
114
115 - def __gt__(self, rhs):
116 """Emulate the C{unicode} class.""" 117 return unicode(self) > rhs
118
119 - def __iter__(self):
120 """Create an iterator of this element's sub-elements.""" 121 for elem in self.sub: 122 yield elem
123
124 - def __le__(self, rhs):
125 """Emulate the C{unicode} class.""" 126 return unicode(self) <= rhs
127
128 - def __len__(self):
129 """Emulate the C{unicode} class.""" 130 return len(unicode(self))
131
132 - def __lt__(self, rhs):
133 """Emulate the C{unicode} class.""" 134 return unicode(self) < rhs
135
136 - def __mul__(self, rhs):
137 """Emulate the C{unicode} class.""" 138 return unicode(self) * rhs
139
140 - def __ne__(self, rhs):
141 return not self.__eq__(rhs)
142
143 - def __radd__(self, lhs):
144 """Emulate the C{unicode} class.""" 145 return self + lhs
146
147 - def __rmul__(self, lhs):
148 """Emulate the C{unicode} class.""" 149 return self * lhs
150
151 - def __repr__(self):
152 elemstr = ', '.join([repr(elem) for elem in self.sub]) 153 return '<%(class)s(%(id)s%(rid)s%(xid)s[%(subs)s])>' % { 154 'class': self.__class__.__name__, 155 'id': self.id is not None and 'id="%s" ' % (self.id) or '', 156 'rid': self.rid is not None and 'rid="%s" ' % (self.rid) or '', 157 'xid': self.xid is not None and 'xid="%s" ' % (self.xid) or '', 158 'subs': elemstr 159 }
160
161 - def __str__(self):
162 if not self.isvisible: 163 return '' 164 return ''.join([unicode(elem).encode('utf-8') for elem in self.sub])
165
166 - def __unicode__(self):
167 if callable(self.renderer): 168 return self.renderer(self) 169 if not self.isvisible: 170 return u'' 171 return u''.join([unicode(elem) for elem in self.sub])
172 173 # METHODS #
174 - def apply_to_strings(self, f):
175 """Apply C{f} to all actual strings in the tree. 176 @param f: Must take one (str or unicode) argument and return a 177 string or unicode.""" 178 for elem in self.flatten(): 179 for i in range(len(elem.sub)): 180 if isinstance(elem.sub[i], basestring): 181 elem.sub[i] = f(elem.sub[i])
182
183 - def copy(self):
184 """Returns a copy of the sub-tree. 185 This should be overridden in sub-classes with more data. 186 187 NOTE: C{self.renderer} is B{not} copied.""" 188 #logging.debug('Copying instance of class %s' % (self.__class__.__name__)) 189 cp = self.__class__(id=self.id, xid=self.xid, rid=self.rid) 190 for sub in self.sub: 191 if isinstance(sub, StringElem): 192 cp.sub.append(sub.copy()) 193 else: 194 cp.sub.append(sub.__class__(sub)) 195 return cp
196
197 - def delete_elem(self, elem):
198 if elem is self: 199 self.sub = [] 200 return 201 parent = self.get_parent_elem(elem) 202 if parent is None: 203 raise ElementNotFoundError(repr(elem)) 204 subidx = -1 205 for i in range(len(parent.sub)): 206 if parent.sub[i] is elem: 207 subidx = i 208 break 209 if subidx < 0: 210 raise ElementNotFoundError(repr(elem)) 211 del parent.sub[subidx]
212
213 - def delete_range(self, start_index, end_index):
214 """Delete the text in the range given by the string-indexes 215 C{start_index} and C{end_index}. 216 Partial nodes will only be removed if they are editable. 217 @returns: A C{StringElem} representing the removed sub-string, the 218 parent node from which it was deleted as well as the offset at 219 which it was deleted from. C{None} is returned for the parent 220 value if the root was deleted. If the parent and offset values 221 are not C{None}, C{parent.insert(offset, deleted)} effectively 222 undoes the delete.""" 223 if start_index == end_index: 224 return StringElem(), self, 0 225 if start_index > end_index: 226 raise IndexError('start_index > end_index: %d > %d' % (start_index, end_index)) 227 if start_index < 0 or start_index > len(self): 228 raise IndexError('start_index: %d' % (start_index)) 229 if end_index < 1 or end_index > len(self) + 1: 230 raise IndexError('end_index: %d' % (end_index)) 231 232 start = self.get_index_data(start_index) 233 if isinstance(start['elem'], tuple): 234 # If {start} is "between" elements, we use the one on the "right" 235 start['elem'] = start['elem'][-1] 236 start['offset'] = start['offset'][-1] 237 end = self.get_index_data(end_index) 238 if isinstance(end['elem'], tuple): 239 # If {end} is "between" elements, we use the one on the "left" 240 end['elem'] = end['elem'][0] 241 end['offset'] = end['offset'][0] 242 assert start['elem'].isleaf() and end['elem'].isleaf() 243 244 #logging.debug('FROM %s TO %s' % (start, end)) 245 246 # Ranges can be one of 3 types: 247 # 1) The entire string. 248 # 2) An entire element. 249 # 3) Restricted to a single element. 250 # 4) Spans multiple elements (start- and ending elements are not the same). 251 252 # Case 1: Entire string # 253 if start_index == 0 and end_index == len(self): 254 #logging.debug('Case 1: [%s]' % (unicode(self))) 255 removed = self.copy() 256 self.sub = [] 257 return removed, None, None 258 259 # Case 2: An entire element # 260 if start['elem'] is end['elem'] and start['offset'] == 0 and end['offset'] == len(start['elem']) or \ 261 (not start['elem'].iseditable and start['elem'].isfragile): 262 ##### FOR DEBUGGING ##### 263 #s = '' 264 #for e in self.flatten(): 265 # if e is start['elem']: 266 # s += '[' + unicode(e) + ']' 267 # else: 268 # s += unicode(e) 269 #logging.debug('Case 2: %s' % (s)) 270 ######################### 271 272 if start['elem'] is self and self.__class__ is StringElem: 273 removed = self.copy() 274 self.sub = [] 275 return removed, None, None 276 removed = start['elem'].copy() 277 parent = self.get_parent_elem(start['elem']) 278 offset = parent.elem_offset(start['elem']) 279 parent.sub.remove(start['elem']) 280 return removed, parent, offset 281 282 # Case 3: Within a single element # 283 if start['elem'] is end['elem'] and start['elem'].iseditable: 284 ##### FOR DEBUGGING ##### 285 #s = '' 286 #for e in self.flatten(): 287 # if e is start['elem']: 288 # s += '%s[%s]%s' % ( 289 # e[:start['offset']], 290 # e[start['offset']:end['offset']], 291 # e[end['offset']:] 292 # ) 293 # else: 294 # s += unicode(e) 295 #logging.debug('Case 3: %s' % (s)) 296 ######################### 297 298 # XXX: This might not have the expected result if start['elem'] is a StringElem sub-class instance. 299 newstr = u''.join(start['elem'].sub) 300 removed = StringElem(newstr[start['offset']:end['offset']]) 301 newstr = newstr[:start['offset']] + newstr[end['offset']:] 302 parent = self.get_parent_elem(start['elem']) 303 if parent is None and start['elem'] is self: 304 parent = self 305 start['elem'].sub = [newstr] 306 self.prune() 307 return removed, start['elem'], start['offset'] 308 309 # Case 4: Across multiple elements # 310 range_nodes = self.depth_first() 311 startidx = 0 312 endidx = -1 313 for i in range(len(range_nodes)): 314 if range_nodes[i] is start['elem']: 315 startidx = i 316 elif range_nodes[i] is end['elem']: 317 endidx = i 318 break 319 range_nodes = range_nodes[startidx:endidx+1] 320 #assert range_nodes[0] is start['elem'] and range_nodes[-1] is end['elem'] 321 322 marked_nodes = [] # Contains nodes that have been marked for deletion (directly or inderectly (via parent)). 323 for node in range_nodes[1:-1]: 324 if node in marked_nodes: 325 continue 326 subtree = node.depth_first() 327 if end['elem'] not in subtree: 328 marked_nodes.extend(subtree) # "subtree" does not include "node" 329 330 ##### FOR DEBUGGING ##### 331 #s = '' 332 #for e in self.flatten(): 333 # if e is start['elem']: 334 # s += '%s[%s' % (e[:start['offset']], e[start['offset']:]) 335 # elif e is end['elem']: 336 # s += '%s]%s' % (e[:end['offset']], e[end['offset']:]) 337 # else: 338 # s += unicode(e) 339 #logging.debug('Case 4: %s' % (s)) 340 ######################### 341 342 removed = self.copy() 343 344 # Save offsets before we start changing the tree 345 start_offset = self.elem_offset(start['elem']) 346 end_offset = self.elem_offset(end['elem']) 347 348 for node in marked_nodes: 349 self.delete_elem(node) 350 351 if start['elem'] is not end['elem']: 352 if start_offset == start['index'] or (not start['elem'].iseditable and start['elem'].isfragile): 353 self.delete_elem(start['elem']) 354 elif start['elem'].iseditable: 355 start['elem'].sub = [ u''.join(start['elem'].sub)[:start['offset']] ] 356 357 if end_offset + len(end['elem']) == end['index'] or (not end['elem'].iseditable and end['elem'].isfragile): 358 self.delete_elem(end['elem']) 359 elif end['elem'].iseditable: 360 end['elem'].sub = [ u''.join(end['elem'].sub)[end['offset']:] ] 361 362 self.prune() 363 return removed, None, None
364
365 - def depth_first(self, filter=None):
366 """Returns a list of the nodes in the tree in depth-first order.""" 367 if filter is None or not callable(filter): 368 filter = lambda e: True 369 elems = [] 370 if filter(self): 371 elems.append(self) 372 373 for sub in self.sub: 374 if not isinstance(sub, StringElem): 375 continue 376 if sub.isleaf() and filter(sub): 377 elems.append(sub) 378 else: 379 elems.extend(sub.depth_first()) 380 return elems
381
382 - def encode(self, encoding=sys.getdefaultencoding()):
383 """More C{unicode} class emulation.""" 384 return unicode(self).encode(encoding)
385
386 - def elem_offset(self, elem):
387 """Find the offset of C{elem} in the current tree. 388 This cannot be reliably used if C{self.renderer} is used and even 389 less so if the rendering function renders the string differently 390 upon different calls. In Virtaal the C{StringElemGUI.index()} method 391 is used as replacement for this one. 392 @returns: The string index where element C{e} starts, or -1 if C{e} 393 was not found.""" 394 offset = 0 395 for e in self.iter_depth_first(): 396 if e is elem: 397 return offset 398 if e.isleaf(): 399 offset += len(e) 400 401 # If we can't find the same instance element, settle for one that looks like it 402 offset = 0 403 for e in self.iter_depth_first(): 404 if e.isleaf(): 405 leafoffset = 0 406 for s in e.sub: 407 if unicode(s) == unicode(elem): 408 return offset + leafoffset 409 else: 410 leafoffset += len(unicode(s)) 411 offset += len(e) 412 return -1
413
414 - def elem_at_offset(self, offset):
415 """Get the C{StringElem} in the tree that contains the string rendered 416 at the given offset.""" 417 if offset < 0 or offset > len(self): 418 return None 419 420 length = 0 421 elem = None 422 for elem in self.flatten(): 423 elem_len = len(elem) 424 if length <= offset < length+elem_len: 425 return elem 426 length += elem_len 427 return elem
428
429 - def find(self, x):
430 """Find sub-string C{x} in this string tree and return the position 431 at which it starts.""" 432 if isinstance(x, basestring): 433 return unicode(self).find(x) 434 if isinstance(x, StringElem): 435 return unicode(self).find(unicode(x)) 436 return None
437
438 - def find_elems_with(self, x):
439 """Find all elements in the current sub-tree containing C{x}.""" 440 return [elem for elem in self.flatten() if x in unicode(elem)]
441
442 - def flatten(self, filter=None):
443 """Flatten the tree by returning a depth-first search over the tree's leaves.""" 444 if filter is None or not callable(filter): 445 filter = lambda e: True 446 return [elem for elem in self.iter_depth_first(lambda e: e.isleaf() and filter(e))]
447
448 - def get_ancestor_where(self, child, criteria):
449 parent = self.get_parent_elem(child) 450 if parent is None or criteria(parent): 451 return parent 452 return self.get_ancestor_where(parent, criteria)
453
454 - def get_index_data(self, index):
455 """Get info about the specified range in the tree. 456 @returns: A dictionary with the following items: 457 * I{elem}: The element in which C{index} resides. 458 * I{index}: Copy of the C{index} parameter 459 * I{offset}: The offset of C{index} into C{'elem'}.""" 460 info = { 461 'elem': self.elem_at_offset(index), 462 'index': index, 463 } 464 info['offset'] = info['index'] - self.elem_offset(info['elem']) 465 466 # Check if there "index" is actually between elements 467 leftelem = self.elem_at_offset(index - 1) 468 if leftelem is not None and leftelem is not info['elem']: 469 info['elem'] = (leftelem, info['elem']) 470 info['offset'] = (len(leftelem), 0) 471 472 return info
473
474 - def get_parent_elem(self, child):
475 """Searches the current sub-tree for and returns the parent of the 476 C{child} element.""" 477 for elem in self.iter_depth_first(): 478 if not isinstance(elem, StringElem): 479 continue 480 for sub in elem.sub: 481 if sub is child: 482 return elem 483 return None
484
485 - def insert(self, offset, text):
486 """Insert the given text at the specified offset of this string-tree's 487 string (Unicode) representation.""" 488 if offset < 0 or offset > len(self) + 1: 489 raise IndexError('Index out of range: %d' % (offset)) 490 if isinstance(text, (str, unicode)): 491 text = StringElem(text) 492 if not isinstance(text, StringElem): 493 raise ValueError('text must be of type StringElem') 494 495 def checkleaf(elem, text): 496 if elem.isleaf() and type(text) is StringElem and text.isleaf(): 497 return unicode(text) 498 return text
499 500 # There are 4 general cases (including specific cases) where text can be inserted: 501 # 1) At the beginning of the string (self) 502 # 1.1) self.sub[0] is editable 503 # 1.2) self.sub[0] is not editable 504 # 2) At the end of the string (self) 505 # 3) In the middle of a node 506 # 4) Between two nodes 507 # 4.1) Neither of the nodes are editable 508 # 4.2) Both nodes are editable 509 # 4.3) Node at offset-1 is editable, node at offset is not 510 # 4.4) Node at offset is editable, node at offset-1 is not 511 512 oelem = self.elem_at_offset(offset) 513 514 # Case 1 # 515 if offset == 0: 516 # 1.1 # 517 if oelem.iseditable: 518 #logging.debug('Case 1.1') 519 oelem.sub.insert(0, checkleaf(oelem, text)) 520 oelem.prune() 521 return True 522 # 1.2 # 523 else: 524 #logging.debug('Case 1.2') 525 oparent = self.get_ancestor_where(oelem, lambda x: x.iseditable) 526 if oparent is not None: 527 oparent.sub.insert(0, checkleaf(oparent, text)) 528 return True 529 else: 530 self.sub.insert(0, checkleaf(self, text)) 531 return True 532 return False 533 534 # Case 2 # 535 if offset >= len(self): 536 #logging.debug('Case 2') 537 last = self.flatten()[-1] 538 parent = self.get_ancestor_where(last, lambda x: x.iseditable) 539 if parent is None: 540 parent = self 541 parent.sub.append(checkleaf(parent, text)) 542 return True 543 544 before = self.elem_at_offset(offset-1) 545 546 # Case 3 # 547 if oelem is before: 548 if oelem.iseditable: 549 #logging.debug('Case 3') 550 eoffset = offset - self.elem_offset(oelem) 551 if oelem.isleaf(): 552 s = unicode(oelem) # Collapse all sibling strings into one 553 head = s[:eoffset] 554 tail = s[eoffset:] 555 if type(text) is StringElem and text.isleaf(): 556 oelem.sub = [head + unicode(text) + tail] 557 else: 558 oelem.sub = [StringElem(head), text, StringElem(tail)] 559 return True 560 else: 561 return oelem.insert(eoffset, text) 562 return False 563 564 # And the only case left: Case 4 # 565 # 4.1 # 566 if not before.iseditable and not oelem.iseditable: 567 #logging.debug('Case 4.1') 568 # Neither are editable, so we add it as a sibling (to the right) of before 569 bparent = self.get_parent_elem(before) 570 # bparent cannot be a leaf (because it has before as a child), so we 571 # insert the text as StringElem(text) 572 bindex = bparent.sub.index(before) 573 bparent.sub.insert(bindex + 1, text) 574 return True 575 576 # 4.2 # 577 elif before.iseditable and oelem.iseditable: 578 #logging.debug('Case 4.2') 579 return before.insert(len(before)+1, text) # Reinterpret as a case 2 580 581 # 4.3 # 582 elif before.iseditable and not oelem.iseditable: 583 #logging.debug('Case 4.3') 584 return before.insert(len(before)+1, text) # Reinterpret as a case 2 585 586 # 4.4 # 587 elif not before.iseditable and oelem.iseditable: 588 #logging.debug('Case 4.4') 589 return oelem.insert(0, text) # Reinterpret as a case 1 590 591 return False
592
593 - def insert_between(self, left, right, text):
594 """Insert the given text between the two parameter C{StringElem}s.""" 595 if not isinstance(left, StringElem) and left is not None: 596 raise ValueError('"left" is not a StringElem or None') 597 if not isinstance(right, StringElem) and right is not None: 598 raise ValueError('"right" is not a StringElem or None') 599 if left is right: 600 if left.sub: 601 # This is an error because the cursor cannot be inside an element ("left is right"), 602 # if it has any other content. If an element has content, it will be at least directly 603 # left or directly right of the current cursor position. 604 raise ValueError('"left" and "right" refer to the same element and is not empty.') 605 if not left.iseditable: 606 return False 607 if isinstance(text, unicode): 608 text = StringElem(text) 609 610 if left is right: 611 #logging.debug('left%s.sub.append(%s)' % (repr(left), repr(text))) 612 left.sub.append(text) 613 return True 614 # XXX: The "in" keyword is *not* used below, because the "in" tests 615 # with __eq__ and not "is", as we do below. Testing for identity is 616 # intentional and required. 617 618 if left is None: 619 if self is right: 620 #logging.debug('self%s.sub.insert(0, %s)' % (repr(self), repr(text))) 621 self.sub.insert(0, text) 622 return True 623 parent = self.get_parent_elem(right) 624 if parent is not None: 625 #logging.debug('parent%s.sub.insert(0, %s)' % (repr(parent), repr(text))) 626 parent.sub.insert(0, text) 627 return True 628 return False 629 630 if right is None: 631 if self is left: 632 #logging.debug('self%s.sub.append(%s)' % (repr(self), repr(text))) 633 self.sub.append(text) 634 return True 635 parent = self.get_parent_elem(left) 636 if parent is not None: 637 #logging.debug('parent%s.sub.append(%s)' % (repr(parent), repr(text))) 638 parent.sub.append(text) 639 return True 640 return False 641 642 # The following two blocks handle the cases where one element 643 # "surrounds" another as its parent. In that way the parent would be 644 # "left" of its first child, like in the first case. 645 ischild = False 646 for sub in left.sub: 647 if right is sub: 648 ischild = True 649 break 650 if ischild: 651 #logging.debug('left%s.sub.insert(0, %s)' % (repr(left), repr(text))) 652 left.sub.insert(0, text) 653 return True 654 655 ischild = False 656 for sub in right.sub: 657 if left is sub: 658 ischild = True 659 break 660 if ischild: 661 #logging.debug('right%s.sub.append(%s)' % (repr(right), repr(text))) 662 right.sub.append(text) 663 return True 664 665 parent = self.get_parent_elem(left) 666 if parent.iseditable: 667 idx = 1 668 for child in parent.sub: 669 if child is left: 670 break 671 idx += 1 672 #logging.debug('parent%s.sub.insert(%d, %s)' % (repr(parent), idx, repr(text))) 673 parent.sub.insert(idx, text) 674 return True 675 676 parent = self.get_parent_elem(right) 677 if parent.iseditable: 678 idx = 0 679 for child in parent.sub: 680 if child is right: 681 break 682 idx += 1 683 #logging.debug('parent%s.sub.insert(%d, %s)' % (repr(parent), idx, repr(text))) 684 parent.sub.insert(0, text) 685 return True 686 687 logging.debug('Could not insert between %s and %s... odd.' % (repr(left), repr(right))) 688 return False
689
690 - def isleaf(self):
691 """ 692 Whether or not this instance is a leaf node in the C{StringElem} tree. 693 694 A node is a leaf node if it is a C{StringElem} (not a sub-class) and 695 contains only sub-elements of type C{str} or C{unicode}. 696 697 @rtype: bool 698 """ 699 for e in self.sub: 700 if not isinstance(e, (str, unicode)): 701 return False 702 return True
703
704 - def iter_depth_first(self, filter=None):
705 """Iterate through the nodes in the tree in dept-first order.""" 706 if filter is None or not callable(filter): 707 filter = lambda e: True 708 if filter(self): 709 yield self 710 for sub in self.sub: 711 if not isinstance(sub, StringElem): 712 continue 713 if sub.isleaf() and filter(sub): 714 yield sub 715 else: 716 for node in sub.iter_depth_first(): 717 if filter(node): 718 yield node
719
720 - def map(self, f, filter=None):
721 """Apply C{f} to all nodes for which C{filter} returned C{True} (optional).""" 722 if filter is not None and not callable(filter): 723 raise ValueError('filter is not callable or None') 724 if filter is None: 725 filter = lambda e: True 726 727 for elem in self.depth_first(): 728 if filter(elem): 729 f(elem)
730 731 @classmethod
732 - def parse(cls, pstr):
733 """Parse an instance of this class from the start of the given string. 734 This method should be implemented by any sub-class that wants to 735 parseable by L{translate.storage.placeables.parse}. 736 737 @type pstr: unicode 738 @param pstr: The string to parse into an instance of this class. 739 @returns: An instance of the current class, or C{None} if the 740 string not parseable by this class.""" 741 return cls(pstr)
742
743 - def print_tree(self, indent=0, verbose=False):
744 """Print the tree from the current instance's point in an indented 745 manner.""" 746 indent_prefix = " " * indent * 2 747 out = (u"%s%s [%s]" % (indent_prefix, self.__class__.__name__, unicode(self))).encode('utf-8') 748 if verbose: 749 out += u' ' + repr(self) 750 751 print out 752 753 for elem in self.sub: 754 if isinstance(elem, StringElem): 755 elem.print_tree(indent+1, verbose=verbose) 756 else: 757 print (u'%s%s[%s]' % (indent_prefix, indent_prefix, elem)).encode('utf-8')
758
759 - def prune(self):
760 """Remove unnecessary nodes to make the tree optimal.""" 761 for elem in self.iter_depth_first(): 762 if len(elem.sub) == 1: 763 child = elem.sub[0] 764 # Symbolically: X->StringElem(leaf) => X(leaf) 765 # (where X is any sub-class of StringElem, but not StringElem) 766 if type(child) is StringElem and child.isleaf(): 767 elem.sub = child.sub 768 769 # Symbolically: StringElem->StringElem2->(leaves) => StringElem->(leaves) 770 if type(elem) is StringElem and type(child) is StringElem: 771 elem.sub = child.sub 772 773 # Symbolically: StringElem->X(leaf) => X(leaf) 774 # (where X is any sub-class of StringElem, but not StringElem) 775 if type(elem) is StringElem and isinstance(child, StringElem) and type(child) is not StringElem: 776 parent = self.get_parent_elem(elem) 777 if parent is not None: 778 parent.sub[parent.sub.index(elem)] = child 779 780 if type(elem) is StringElem and elem.isleaf(): 781 # Collapse all strings in this leaf into one string. 782 elem.sub = [u''.join(elem.sub)] 783 784 for i in reversed(range(len(elem.sub))): 785 # Remove empty strings or StringElem nodes 786 # (but not StringElem sub-class instances, because they might contain important (non-rendered) data. 787 if type(elem.sub[i]) in (StringElem, str, unicode) and len(elem.sub[i]) == 0: 788 del elem.sub[i] 789 continue 790 791 if type(elem.sub[i]) in (str, unicode) and not elem.isleaf(): 792 elem.sub[i] = StringElem(elem.sub[i]) 793 794 # Merge sibling StringElem leaves 795 if not elem.isleaf(): 796 changed = True 797 while changed: 798 changed = False 799 800 for i in range(len(elem.sub)-1): 801 lsub = elem.sub[i] 802 rsub = elem.sub[i+1] 803 804 if type(lsub) is StringElem and type(rsub) is StringElem: 805 lsub.sub.extend(rsub.sub) 806 del elem.sub[i+1] 807 changed = True 808 break
809 810 # TODO: Write unit test for this method
811 - def remove_type(self, ptype):
812 """Replace nodes with type C{ptype} with base C{StringElem}s, containing 813 the same sub-elements. This is only applicable to elements below the 814 element tree root node.""" 815 for elem in self.iter_depth_first(): 816 if type(elem) is ptype: 817 parent = self.get_parent_elem(elem) 818 pindex = parent.sub.index(elem) 819 parent.sub[pindex] = StringElem( 820 sub=elem.sub, 821 id=elem.id, 822 xid=elem.xid, 823 rid=elem.rid 824 )
825
826 - def translate(self):
827 """Transform the sub-tree according to some class-specific needs. 828 This method should be either overridden in implementing sub-classes 829 or dynamically replaced by specific applications. 830 831 @returns: The transformed Unicode string representing the sub-tree. 832 """ 833 return self.copy()
834