gluon.template

1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 """ 5 This file is part of the web2py Web Framework (Copyrighted, 2007-2011). 6 License: LGPLv3 (http://www.gnu.org/licenses/lgpl.html) 7 8 Author: Thadeus Burgess 9 10 Contributors: 11 12 - Thank you to Massimo Di Pierro for creating the original gluon/template.py 13 - Thank you to Jonathan Lundell for extensively testing the regex on Jython. 14 - Thank you to Limodou (creater of uliweb) who inspired the block-element support for web2py. 15 """ 16 17 import os 18 import cgi 19 import logging 20 from re import compile, sub, escape, DOTALL 21 try: 22 import cStringIO as StringIO 23 except: 24 from io import StringIO 25 26 try: 27 # have web2py 28 from restricted import RestrictedError 29 from globals import current 30 except ImportError: 31 # do not have web2py 32 current = None 33

34 - def RestrictedError(a, b, c):

35 logging.error(str(a) + ':' + str(b) + ':' + str(c)) 36 return RuntimeError

37 38

39 -class Node(object):

40 """ 41 Basic Container Object 42 """

43 - def __init__(self, value=None, pre_extend=False):

44 self.value = value 45 self.pre_extend = pre_extend

46

47 - def __str__(self):

48 return str(self.value)

49 50

51 -class SuperNode(Node):

52 - def __init__(self, name='', pre_extend=False):

53 self.name = name 54 self.value = None 55 self.pre_extend = pre_extend

56

57 - def __str__(self):

58 if self.value: 59 return str(self.value) 60 else: 61 # raise SyntaxError("Undefined parent block ``%s``. \n" % self.name + "You must define a block before referencing it.\nMake sure you have not left out an ``{{end}}`` tag." ) 62 return ''

63

64 - def __repr__(self):

65 return "%s->%s" % (self.name, self.value)

66 67

68 -def output_aux(node, blocks):

69 # If we have a block level 70 # If we can override this block. 71 # Override block from vars. 72 # Else we take the default 73 # Else its just a string 74 return (blocks[node.name].output(blocks) 75 if node.name in blocks else 76 node.output(blocks)) \ 77 if isinstance(node, BlockNode) \ 78 else str(node)

79 80

81 -class BlockNode(Node):

82 """ 83 Block Container. 84 85 This Node can contain other Nodes and will render in a hierarchical order 86 of when nodes were added. 87 88 ie:: 89 90 {{ block test }} 91 This is default block test 92 {{ end }} 93 """

94 - def __init__(self, name='', pre_extend=False, delimiters=('{{', '}}')):

95 """ 96 name - Name of this Node. 97 """ 98 self.nodes = [] 99 self.name = name 100 self.pre_extend = pre_extend 101 self.left, self.right = delimiters

102

103 - def __repr__(self):

104 lines = ['%sblock %s%s' % (self.left, self.name, self.right)] 105 lines += [str(node) for node in self.nodes] 106 lines.append('%send%s' % (self.left, self.right)) 107 return ''.join(lines)

108

109 - def __str__(self):

110 """ 111 Get this BlockNodes content, not including child Nodes 112 """ 113 return ''.join(str(node) for node in self.nodes 114 if not isinstance(node, BlockNode))

115

116 - def append(self, node):

117 """ 118 Add an element to the nodes. 119 120 Keyword Arguments 121 122 - node -- Node object or string to append. 123 """ 124 if isinstance(node, str) or isinstance(node, Node): 125 self.nodes.append(node) 126 else: 127 raise TypeError("Invalid type; must be instance of ``str`` or ``BlockNode``. %s" % node)

128

129 - def extend(self, other):

130 """ 131 Extend the list of nodes with another BlockNode class. 132 133 Keyword Arguments 134 135 - other -- BlockNode or Content object to extend from. 136 """ 137 if isinstance(other, BlockNode): 138 self.nodes.extend(other.nodes) 139 else: 140 raise TypeError( 141 "Invalid type; must be instance of ``BlockNode``. %s" % other)

142

143 - def output(self, blocks):

144 """ 145 Merges all nodes into a single string. 146 blocks -- Dictionary of blocks that are extending 147 from this template. 148 """ 149 return ''.join(output_aux(node, blocks) for node in self.nodes)

150 151

152 -class Content(BlockNode):

153 """ 154 Parent Container -- Used as the root level BlockNode. 155 156 Contains functions that operate as such. 157 """

158 - def __init__(self, name="ContentBlock", pre_extend=False):

159 """ 160 Keyword Arguments 161 162 name -- Unique name for this BlockNode 163 """ 164 self.name = name 165 self.nodes = [] 166 self.blocks = {} 167 self.pre_extend = pre_extend

168

169 - def __str__(self):

170 return ''.join(output_aux(node, self.blocks) for node in self.nodes)

171

172 - def _insert(self, other, index=0):

173 """ 174 Inserts object at index. 175 """ 176 if isinstance(other, (str, Node)): 177 self.nodes.insert(index, other) 178 else: 179 raise TypeError( 180 "Invalid type, must be instance of ``str`` or ``Node``.")

181

182 - def insert(self, other, index=0):

183 """ 184 Inserts object at index. 185 186 You may pass a list of objects and have them inserted. 187 """ 188 if isinstance(other, (list, tuple)): 189 # Must reverse so the order stays the same. 190 other.reverse() 191 for item in other: 192 self._insert(item, index) 193 else: 194 self._insert(other, index)

195

196 - def append(self, node):

197 """ 198 Adds a node to list. If it is a BlockNode then we assign a block for it. 199 """ 200 if isinstance(node, (str, Node)): 201 self.nodes.append(node) 202 if isinstance(node, BlockNode): 203 self.blocks[node.name] = node 204 else: 205 raise TypeError("Invalid type, must be instance of ``str`` or ``BlockNode``. %s" % node)

206

207 - def extend(self, other):

208 """ 209 Extends the objects list of nodes with another objects nodes 210 """ 211 if isinstance(other, BlockNode): 212 self.nodes.extend(other.nodes) 213 self.blocks.update(other.blocks) 214 else: 215 raise TypeError( 216 "Invalid type; must be instance of ``BlockNode``. %s" % other)

217

218 - def clear_content(self):

219 self.nodes = []

220 221

222 -class TemplateParser(object):

223 224 default_delimiters = ('{{', '}}') 225 r_tag = compile(r'(\{\{.*?\}\})', DOTALL) 226 227 r_multiline = compile(r'(""".*?""")|(\'\'\'.*?\'\'\')', DOTALL) 228 229 # These are used for re-indentation. 230 # Indent + 1 231 re_block = compile('^(elif |else:|except:|except |finally:).*$', DOTALL) 232 233 # Indent - 1 234 re_unblock = compile('^(return|continue|break|raise)( .*)?$', DOTALL) 235 # Indent - 1 236 re_pass = compile('^pass( .*)?$', DOTALL) 237

238 - def __init__(self, text, 239 name="ParserContainer", 240 context=dict(), 241 path='views/', 242 writer='response.write', 243 lexers={}, 244 delimiters=('{{', '}}'), 245 _super_nodes = [], 246 ):

247 """ 248 text -- text to parse 249 context -- context to parse in 250 path -- folder path to templates 251 writer -- string of writer class to use 252 lexers -- dict of custom lexers to use. 253 delimiters -- for example ('{{','}}') 254 _super_nodes -- a list of nodes to check for inclusion 255 this should only be set by "self.extend" 256 It contains a list of SuperNodes from a child 257 template that need to be handled. 258 """ 259 260 # Keep a root level name. 261 self.name = name 262 # Raw text to start parsing. 263 self.text = text 264 # Writer to use (refer to the default for an example). 265 # This will end up as 266 # "%s(%s, escape=False)" % (self.writer, value) 267 self.writer = writer 268 269 # Dictionary of custom name lexers to use. 270 if isinstance(lexers, dict): 271 self.lexers = lexers 272 else: 273 self.lexers = {} 274 275 # Path of templates 276 self.path = path 277 # Context for templates. 278 self.context = context 279 280 # allow optional alternative delimiters 281 self.delimiters = delimiters 282 if delimiters != self.default_delimiters: 283 escaped_delimiters = (escape(delimiters[0]), 284 escape(delimiters[1])) 285 self.r_tag = compile(r'(%s.*?%s)' % escaped_delimiters, DOTALL) 286 elif hasattr(context.get('response', None), 'delimiters'): 287 if context['response'].delimiters != self.default_delimiters: 288 escaped_delimiters = ( 289 escape(context['response'].delimiters[0]), 290 escape(context['response'].delimiters[1])) 291 self.r_tag = compile(r'(%s.*?%s)' % escaped_delimiters, 292 DOTALL) 293 294 # Create a root level Content that everything will go into. 295 self.content = Content(name=name) 296 297 # Stack will hold our current stack of nodes. 298 # As we descend into a node, it will be added to the stack 299 # And when we leave, it will be removed from the stack. 300 # self.content should stay on the stack at all times. 301 self.stack = [self.content] 302 303 # This variable will hold a reference to every super block 304 # that we come across in this template. 305 self.super_nodes = [] 306 307 # This variable will hold a reference to the child 308 # super nodes that need handling. 309 self.child_super_nodes = _super_nodes 310 311 # This variable will hold a reference to every block 312 # that we come across in this template 313 self.blocks = {} 314 315 # Begin parsing. 316 self.parse(text)

317

318 - def to_string(self):

319 """ 320 Return the parsed template with correct indentation. 321 322 Used to make it easier to port to python3. 323 """ 324 return self.reindent(str(self.content))

325

326 - def __str__(self):

327 "Make sure str works exactly the same as python 3" 328 return self.to_string()

329

330 - def __unicode__(self):

331 "Make sure str works exactly the same as python 3" 332 return self.to_string()

333

334 - def reindent(self, text):

335 """ 336 Reindents a string of unindented python code. 337 """ 338 339 # Get each of our lines into an array. 340 lines = text.split('\n') 341 342 # Our new lines 343 new_lines = [] 344 345 # Keeps track of how many indents we have. 346 # Used for when we need to drop a level of indentation 347 # only to reindent on the next line. 348 credit = 0 349 350 # Current indentation 351 k = 0 352 353 ################# 354 # THINGS TO KNOW 355 ################# 356 357 # k += 1 means indent 358 # k -= 1 means unindent 359 # credit = 1 means unindent on the next line. 360 361 for raw_line in lines: 362 line = raw_line.strip() 363 364 # ignore empty lines 365 if not line: 366 continue 367 368 # If we have a line that contains python code that 369 # should be unindented for this line of code. 370 # and then reindented for the next line. 371 if TemplateParser.re_block.match(line): 372 k = k + credit - 1 373 374 # We obviously can't have a negative indentation 375 k = max(k, 0) 376 377 # Add the indentation! 378 new_lines.append(' ' * (4 * k) + line) 379 380 # Bank account back to 0 again :( 381 credit = 0 382 383 # If we are a pass block, we obviously de-dent. 384 if TemplateParser.re_pass.match(line): 385 k -= 1 386 387 # If we are any of the following, de-dent. 388 # However, we should stay on the same level 389 # But the line right after us will be de-dented. 390 # So we add one credit to keep us at the level 391 # while moving back one indentation level. 392 if TemplateParser.re_unblock.match(line): 393 credit = 1 394 k -= 1 395 396 # If we are an if statement, a try, or a semi-colon we 397 # probably need to indent the next line. 398 if line.endswith(':') and not line.startswith('#'): 399 k += 1 400 401 # This must come before so that we can raise an error with the 402 # right content. 403 new_text = '\n'.join(new_lines) 404 405 if k > 0: 406 self._raise_error('missing "pass" in view', new_text) 407 elif k < 0: 408 self._raise_error('too many "pass" in view', new_text) 409 410 return new_text

411

412 - def _raise_error(self, message='', text=None):

413 """ 414 Raise an error using itself as the filename and textual content. 415 """ 416 raise RestrictedError(self.name, text or self.text, message)

417

418 - def _get_file_text(self, filename):

419 """ 420 Attempt to open ``filename`` and retrieve its text. 421 422 This will use self.path to search for the file. 423 """ 424 425 # If they didn't specify a filename, how can we find one! 426 if not filename.strip(): 427 self._raise_error('Invalid template filename') 428 429 # Allow Views to include other views dynamically 430 context = self.context 431 if current and not "response" in context: 432 context["response"] = getattr(current, 'response', None) 433 434 # Get the filename; filename looks like ``"template.html"``. 435 # We need to eval to remove the quotes and get the string type. 436 filename = eval(filename, context) 437 438 # Get the path of the file on the system. 439 filepath = self.path and os.path.join(self.path, filename) or filename 440 441 # try to read the text. 442 try: 443 fileobj = open(filepath, 'rb') 444 text = fileobj.read() 445 fileobj.close() 446 except IOError: 447 self._raise_error('Unable to open included view file: ' + filepath) 448 449 return text

450

451 - def include(self, content, filename):

452 """ 453 Include ``filename`` here. 454 """ 455 text = self._get_file_text(filename) 456 457 t = TemplateParser(text, 458 name=filename, 459 context=self.context, 460 path=self.path, 461 writer=self.writer, 462 delimiters=self.delimiters) 463 464 content.append(t.content)

465

466 - def extend(self, filename):

467 """ 468 Extend ``filename``. Anything not declared in a block defined by the 469 parent will be placed in the parent templates ``{{include}}`` block. 470 """ 471 text = self._get_file_text(filename) 472 473 # Create out nodes list to send to the parent 474 super_nodes = [] 475 # We want to include any non-handled nodes. 476 super_nodes.extend(self.child_super_nodes) 477 # And our nodes as well. 478 super_nodes.extend(self.super_nodes) 479 480 t = TemplateParser(text, 481 name=filename, 482 context=self.context, 483 path=self.path, 484 writer=self.writer, 485 delimiters=self.delimiters, 486 _super_nodes=super_nodes) 487 488 # Make a temporary buffer that is unique for parent 489 # template. 490 buf = BlockNode( 491 name='__include__' + filename, delimiters=self.delimiters) 492 pre = [] 493 494 # Iterate through each of our nodes 495 for node in self.content.nodes: 496 # If a node is a block 497 if isinstance(node, BlockNode): 498 # That happens to be in the parent template 499 if node.name in t.content.blocks: 500 # Do not include it 501 continue 502 503 if isinstance(node, Node): 504 # Or if the node was before the extension 505 # we should not include it 506 if node.pre_extend: 507 pre.append(node) 508 continue 509 510 # Otherwise, it should go int the 511 # Parent templates {{include}} section. 512 buf.append(node) 513 else: 514 buf.append(node) 515 516 # Clear our current nodes. We will be replacing this with 517 # the parent nodes. 518 self.content.nodes = [] 519 520 t_content = t.content 521 522 # Set our include, unique by filename 523 t_content.blocks['__include__' + filename] = buf 524 525 # Make sure our pre_extended nodes go first 526 t_content.insert(pre) 527 528 # Then we extend our blocks 529 t_content.extend(self.content) 530 531 # Work off the parent node. 532 self.content = t_content

533

534 - def parse(self, text):

535 536 # Basically, r_tag.split will split the text into 537 # an array containing, 'non-tag', 'tag', 'non-tag', 'tag' 538 # so if we alternate this variable, we know 539 # what to look for. This is alternate to 540 # line.startswith("{{") 541 in_tag = False 542 extend = None 543 pre_extend = True 544 545 # Use a list to store everything in 546 # This is because later the code will "look ahead" 547 # for missing strings or brackets. 548 ij = self.r_tag.split(text) 549 # j = current index 550 # i = current item 551 stack = self.stack 552 for j in range(len(ij)): 553 i = ij[j] 554 555 if i: 556 if not stack: 557 self._raise_error('The "end" tag is unmatched, please check if you have a starting "block" tag') 558 559 # Our current element in the stack. 560 top = stack[-1] 561 562 if in_tag: 563 line = i 564 565 # Get rid of delimiters 566 line = line[len(self.delimiters[0]):-len(self.delimiters[1])].strip() 567 568 # This is bad juju, but let's do it anyway 569 if not line: 570 continue 571 572 # We do not want to replace the newlines in code, 573 # only in block comments. 574 def remove_newline(re_val): 575 # Take the entire match and replace newlines with 576 # escaped newlines. 577 return re_val.group(0).replace('\n', '\\n')

578 579 # Perform block comment escaping. 580 # This performs escaping ON anything 581 # in between """ and """ 582 line = sub(TemplateParser.r_multiline, 583 remove_newline, 584 line) 585 586 if line.startswith('='): 587 # IE: {{=response.title}} 588 name, value = '=', line[1:].strip() 589 else: 590 v = line.split(' ', 1) 591 if len(v) == 1: 592 # Example 593 # {{ include }} 594 # {{ end }} 595 name = v[0] 596 value = '' 597 else: 598 # Example 599 # {{ block pie }} 600 # {{ include "layout.html" }} 601 # {{ for i in range(10): }} 602 name = v[0] 603 value = v[1] 604 605 # This will replace newlines in block comments 606 # with the newline character. This is so that they 607 # retain their formatting, but squish down to one 608 # line in the rendered template. 609 610 # First check if we have any custom lexers 611 if name in self.lexers: 612 # Pass the information to the lexer 613 # and allow it to inject in the environment 614 615 # You can define custom names such as 616 # '{{<<variable}}' which could potentially 617 # write unescaped version of the variable. 618 self.lexers[name](parser=self, 619 value=value, 620 top=top, 621 stack=stack) 622 623 elif name == '=': 624 # So we have a variable to insert into 625 # the template 626 buf = "\n%s(%s)" % (self.writer, value) 627 top.append(Node(buf, pre_extend=pre_extend)) 628 629 elif name == 'block' and not value.startswith('='): 630 # Make a new node with name. 631 node = BlockNode(name=value.strip(), 632 pre_extend=pre_extend, 633 delimiters=self.delimiters) 634 635 # Append this node to our active node 636 top.append(node) 637 638 # Make sure to add the node to the stack. 639 # so anything after this gets added 640 # to this node. This allows us to 641 # "nest" nodes. 642 stack.append(node) 643 644 elif name == 'end' and not value.startswith('='): 645 # We are done with this node. 646 647 # Save an instance of it 648 self.blocks[top.name] = top 649 650 # Pop it. 651 stack.pop() 652 653 elif name == 'super' and not value.startswith('='): 654 # Get our correct target name 655 # If they just called {{super}} without a name 656 # attempt to assume the top blocks name. 657 if value: 658 target_node = value 659 else: 660 target_node = top.name 661 662 # Create a SuperNode instance 663 node = SuperNode(name=target_node, 664 pre_extend=pre_extend) 665 666 # Add this to our list to be taken care of 667 self.super_nodes.append(node) 668 669 # And put in in the tree 670 top.append(node) 671 672 elif name == 'include' and not value.startswith('='): 673 # If we know the target file to include 674 if value: 675 self.include(top, value) 676 677 # Otherwise, make a temporary include node 678 # That the child node will know to hook into. 679 else: 680 include_node = BlockNode( 681 name='__include__' + self.name, 682 pre_extend=pre_extend, 683 delimiters=self.delimiters) 684 top.append(include_node) 685 686 elif name == 'extend' and not value.startswith('='): 687 # We need to extend the following 688 # template. 689 extend = value 690 pre_extend = False 691 692 else: 693 # If we don't know where it belongs 694 # we just add it anyways without formatting. 695 if line and in_tag: 696 697 # Split on the newlines >.< 698 tokens = line.split('\n') 699 700 # We need to look for any instances of 701 # for i in range(10): 702 # = i 703 # pass 704 # So we can properly put a response.write() in place. 705 continuation = False 706 len_parsed = 0 707 for k, token in enumerate(tokens): 708 709 token = tokens[k] = token.strip() 710 len_parsed += len(token) 711 712 if token.startswith('='): 713 if token.endswith('\\'): 714 continuation = True 715 tokens[k] = "\n%s(%s" % ( 716 self.writer, token[1:].strip()) 717 else: 718 tokens[k] = "\n%s(%s)" % ( 719 self.writer, token[1:].strip()) 720 elif continuation: 721 tokens[k] += ')' 722 continuation = False 723 724 buf = "\n%s" % '\n'.join(tokens) 725 top.append(Node(buf, pre_extend=pre_extend)) 726 727 else: 728 # It is HTML so just include it. 729 buf = "\n%s(%r, escape=False)" % (self.writer, i) 730 top.append(Node(buf, pre_extend=pre_extend)) 731 732 # Remember: tag, not tag, tag, not tag 733 in_tag = not in_tag 734 735 # Make a list of items to remove from child 736 to_rm = [] 737 738 # Go through each of the children nodes 739 for node in self.child_super_nodes: 740 # If we declared a block that this node wants to include 741 if node.name in self.blocks: 742 # Go ahead and include it! 743 node.value = self.blocks[node.name] 744 # Since we processed this child, we don't need to 745 # pass it along to the parent 746 to_rm.append(node) 747 748 # Remove some of the processed nodes 749 for node in to_rm: 750 # Since this is a pointer, it works beautifully. 751 # Sometimes I miss C-Style pointers... I want my asterisk... 752 self.child_super_nodes.remove(node) 753 754 # If we need to extend a template. 755 if extend: 756 self.extend(extend)

757 758 # We need this for integration with gluon 759 760

761 -def parse_template(filename, 762 path='views/', 763 context=dict(), 764 lexers={}, 765 delimiters=('{{', '}}') 766 ):

767 """ 768 filename can be a view filename in the views folder or an input stream 769 path is the path of a views folder 770 context is a dictionary of symbols used to render the template 771 """ 772 773 # First, if we have a str try to open the file 774 if isinstance(filename, str): 775 try: 776 fp = open(os.path.join(path, filename), 'rb') 777 text = fp.read() 778 fp.close() 779 except IOError: 780 raise RestrictedError(filename, '', 'Unable to find the file') 781 else: 782 text = filename.read() 783 784 # Use the file contents to get a parsed template and return it. 785 return str(TemplateParser(text, context=context, path=path, lexers=lexers, delimiters=delimiters))

786 787

788 -def get_parsed(text):

789 """ 790 Returns the indented python code of text. Useful for unit testing. 791 792 """ 793 return str(TemplateParser(text))

794 795

796 -class DummyResponse():

797 - def __init__(self):

798 self.body = StringIO.StringIO()

799

800 - def write(self, data, escape=True):

801 if not escape: 802 self.body.write(str(data)) 803 elif hasattr(data, 'as_html') and callable(data.as_html): 804 self.body.write(data.as_html()) 805 else: 806 # make it a string 807 if not isinstance(data, (str, unicode)): 808 data = str(data) 809 elif isinstance(data, unicode): 810 data = data.encode('utf8', 'xmlcharrefreplace') 811 data = cgi.escape(data, True).replace("'", "'") 812 self.body.write(data)

813 814

815 -class NOESCAPE():

816 """ 817 A little helper to avoid escaping. 818 """

819 - def __init__(self, text):

820 self.text = text

821

822 - def xml(self):

823 return self.text

824 825 # And this is a generic render function. 826 # Here for integration with gluon. 827 828

829 -def render(content="hello world", 830 stream=None, 831 filename=None, 832 path=None, 833 context={}, 834 lexers={}, 835 delimiters=('{{', '}}'), 836 writer='response.write' 837 ):

838 """ 839 >>> render() 840 'hello world' 841 >>> render(content='abc') 842 'abc' 843 >>> render(content='abc\\'') 844 "abc'" 845 >>> render(content='a"\\'bc') 846 'a"\\'bc' 847 >>> render(content='a\\nbc') 848 'a\\nbc' 849 >>> render(content='a"bcd"e') 850 'a"bcd"e' 851 >>> render(content="'''a\\nc'''") 852 "'''a\\nc'''" 853 >>> render(content="'''a\\'c'''") 854 "'''a\'c'''" 855 >>> render(content='{{for i in range(a):}}{{=i}} {{pass}}', context=dict(a=5)) 856 '0 1 2 3 4 ' 857 >>> render(content='{%for i in range(a):%}{%=i%} {%pass%}', context=dict(a=5),delimiters=('{%','%}')) 858 '0 1 2 3 4 ' 859 >>> render(content="{{='''hello\\nworld'''}}") 860 'hello\\nworld' 861 >>> render(content='{{for i in range(3):\\n=i\\npass}}') 862 '012' 863 """ 864 # here to avoid circular Imports 865 try: 866 from globals import Response 867 except ImportError: 868 # Working standalone. Build a mock Response object. 869 Response = DummyResponse 870 871 # Add it to the context so we can use it. 872 if not 'NOESCAPE' in context: 873 context['NOESCAPE'] = NOESCAPE 874 875 # save current response class 876 if context and 'response' in context: 877 old_response_body = context['response'].body 878 context['response'].body = StringIO.StringIO() 879 else: 880 old_response_body = None 881 context['response'] = Response() 882 883 # If we don't have anything to render, why bother? 884 if not content and not stream and not filename: 885 raise SyntaxError("Must specify a stream or filename or content") 886 887 # Here for legacy purposes, probably can be reduced to 888 # something more simple. 889 close_stream = False 890 if not stream: 891 if filename: 892 stream = open(filename, 'rb') 893 close_stream = True 894 elif content: 895 stream = StringIO.StringIO(content) 896 897 # Execute the template. 898 code = str(TemplateParser(stream.read( 899 ), context=context, path=path, lexers=lexers, delimiters=delimiters, writer=writer)) 900 try: 901 exec(code) in context 902 except Exception: 903 # for i,line in enumerate(code.split('\n')): print i,line 904 raise 905 906 if close_stream: 907 stream.close() 908 909 # Returned the rendered content. 910 text = context['response'].body.getvalue() 911 if old_response_body is not None: 912 context['response'].body = old_response_body 913 return text

914 915 916 if __name__ == '__main__': 917 import doctest 918 doctest.testmod() 919

Source Code for Module gluon.template