1
=== modified file 'CHANGES'
2
--- CHANGES	2007-11-18 14:59:06 +0000
3
+++ CHANGES	2010-10-19 20:12:51 +0000
4
@@ -1,6 +1,94 @@
8
1
Please initial your changes (there's a key at bottom) and add a date for each
1
2.4.2 (February 8th, 2010)
9
2
release
2
  - Fix issue where subclasses of Template failed to pick up attributes in the
10
3
================================================================================
3
    searchlist
11
4
  - Remove old/outdated bundled memcached python client
12
5
  - Allow for #encoding directives to exist after a comment (i.e. not the first
13
6
    line in a module)
14
7
  - Remove support for WebWare servlets (which caused significant performance
15
8
    slowdowns on Mac OS X)
16
9
  - Old/stale code pruned in preparation for Python 3 support
17
10
18
11
2.4.1 (December 19th, 2009)
19
12
  - --quiet flag added to `cheetah` to silence printing to stdout (abbeyj)
20
13
  - Refactoring to minimize the amount of forked code for Python3 (rtyler)
21
14
  - Template.compile() will no longer create class names with numerous leading
22
15
    underscores (rtyler; reported by Kirill Uhanov)
23
16
  - DirectiveAnalyzer (cheetah-analyze script) added to report directive usage in templates (rtyler)
24
17
  - Older LaTeX docs converted to rst for Sphinx (rtyler)
25
18
  - Prevent #raw blocks from evaluating $-placeholders and escaped strings (karmix0)
26
19
  - New tests added to verify PSP behavior and other untested internals (rtyler)
27
20
28
21
2.4.0 (October 24th, 2009)
29
22
  - Fix a major performance regression in Template.__init__()
30
23
  - More graceful handling of unicode when calling .respond() to render a template
31
24
  - Minor code updates
32
25
  - Update the default filter (thanks mikeb!)
33
26
34
27
2.3.0 (October 24th, 2009) (loosely equivalent to 2.4.0)
35
28
  - Fix a major performance regression in Template.__init__()
36
29
  - More graceful handling of unicode when calling .respond() to render a template
37
30
  - Minor code updates
38
31
  - Update the default filter (thanks mikeb!)
39
32
40
33
2.2.2 (September 10th, 2009)
41
34
  - Prevent _namemapper.c from segfaulting when PyImport_ImportModule fails for some reason (Bogdano Arendartchuk <debogdano@gmail.com>)
42
35
  - Removal of the contrib/markdown module (in favor of a setuptools dependency)
43
36
  - Default setup.py to use setuptools by default, failing that, fall back to distutils
44
37
  - Improvements to setup.py to support building for Windows (thanks abbeyj!)
45
38
  - Improvements to C-based NameMapper for Windows
46
39
  - Fixes for a swath of unit tests on Windows
47
40
  - Re-enabling the EOL tests (whoops)
48
41
  - Fix for unicode/utf-8 dynamic compilation error (thanks mikeb!) (Test.Unicode.JBQ_UTF8_Test8)
49
42
  - 0000010: [Templates] Failure to execute templates on Google App Engine (rtyler) 
50
43
  - 0000026: [Compiler] Support multiple inheritance (rtyler) 
51
44
52
45
53
46
2.2.1 (June 1st, 2009)
54
47
  - 0000020: [Templates] Builtin support for using Cheetah with Django (rtyler) 
55
48
  - 0000021: [Compiler] @static and @classmethod don't properly define the _filter local (rtyler) 
56
49
  - 0000023: [Compiler] Update Template super calls to use super() (rtyler) 
57
50
  - Update all references to communitycheetah.org to point back at cheetahtemplate.org
58
51
59
52
2.2.0 (May 17th, 2009)
60
53
  - Switch all internal representations of template code to unicode objects instead of str() objects
61
54
  - Convert unicode compiled template to an utf8 char buffer when writing to a file (Jean-Baptiste Quenot <jbq@caraldi.com>)
62
55
  - 0000011: [Templates] Calling a function with arguments calls the function with None (rtyler) 
63
56
  - 0000015: [Tests] Resolve test failures in 'next' branch (rtyler)
64
57
  - 0000019: [Templates] Properly warn when joining unicode and non-unicode objects in DummyTransaction (rtyler)
65
58
66
59
2.1.2 (May 5, 2009)
67
60
  - 0000006: [Templates] Support @staticmethod and @classmethod (rtyler) 
68
61
69
62
2.1.1 (April 16, 2009)
70
63
  - Support __eq__() and __ne__() the way you might expect in src/Tools/RecursiveNull (patch suggested by Peter Warasin <peter@endian.com>)
71
64
  - Applied patch to avoid hitting the filesystem to get the file modification time everytime a #include directive is processed (Jean-Baptiste Quenot <jbq@caraldi.com>)
72
65
  - Applied patch to fix some annoying cases when Cheetah writes to stderr instead of propagating the exception (Jean-Baptiste Quenot <jbq@caraldi.com>)
73
66
  - Added KDE editor support
74
67
  - Applied patch to correct importHook behavior on Python 2.6 (reported/patched by Toshio Ernie Kuratomi <a.badger@gmail.com>)
75
68
  - Correct unicode issue when calling/embedding unicode templates inside of other templtes (testcase Tests.Unicode.JPQ_UTF8_Test3. reported by Jean-Baptiste Quenot <jbq@caraldi.com>)
76
69
  - Added --shbang option (e.g. "cheetah compile --shbang '#!/usr/bin/python2.6' ")
77
70
  - Removed dependency on optik OptionParser in favor of builtin Python optparse module
78
71
  - Introduction of the #transform directive for whole-document filtering
79
72
  - Introduction of Cheetah.contrib.markdown and Cheetah.Filters.Markdown for outputting a markdown processed template (meant for #transform)
80
73
  - Cheetah.Filters.CodeHighlighter, pygments-based code highlighting filter for use with #transform
81
74
  - Addition of "useLegacyImportMode" compiler setting (defaulted to True) to allow for older (read: broken) import behavior
82
75
83
76
2.1.0.1 (March 27, 2009)
84
77
  - Fix inline import issue introduced in v2.1.0
85
78
86
79
2.1.0 (March 16, 2009)
87
80
  - Quiet DeprecationWarnings being printed to stderr when using Cheetah on Python 2.6 and up. Patch suggested by Satoru SATOH <satoru.satoh@gmail.com>
88
81
  - Apply patch to support parallel compilation of templates courtesy of Evan Klitzke <evan@eklitzke.org>
89
82
  - Corrected issue when __getattr__ calls on searchList objects raise exceptions (tyler@slide.com)
90
83
  - make autocalling in valueForName correctly ignore newstyle classes and instances
91
84
    that are callable, as it does for oldstyle classes and instances.  Patch
92
85
    from lucas@endian.com
93
86
    [TR]
94
87
  - made it possible to chain multiple decorators to a method #def [TR with
95
88
    patch from Graham Dennis]
96
89
  - fixed a bug in _eatMultiLineDef that Graham Dennis reported. [TR] 
97
90
  - fixed 'module.__init__() argument 1 must be string, not unicode' bug in
98
91
    Template.py reported by Erwin Ambrosch [TR]
99
4
92
100
5
2.0.1 (Nov 16, 2007)
93
2.0.1 (Nov 16, 2007)
101
6
  - fixed a deadlock Christoph Zwerschke found in Cheetah.ImportHooks.
94
  - fixed a deadlock Christoph Zwerschke found in Cheetah.ImportHooks.
102
7
95
103
=== added directory 'Cheetah.egg-info'
104
=== added file 'Cheetah.egg-info/PKG-INFO'
105
--- Cheetah.egg-info/PKG-INFO	1970-01-01 00:00:00 +0000
106
+++ Cheetah.egg-info/PKG-INFO	2010-10-19 20:12:51 +0000
107
@@ -0,0 +1,47 @@
108
1
Metadata-Version: 1.0
109
2
Name: Cheetah
110
3
Version: 2.4.3
111
4
Summary: Cheetah is a template engine and code generation tool.
112
5
Home-page: http://www.cheetahtemplate.org/
113
6
Author: R. Tyler Ballance
114
7
Author-email: cheetahtemplate-discuss@lists.sf.net
115
8
License: UNKNOWN
116
9
Description: Cheetah is an open source template engine and code generation tool.
117
10
        
118
11
        It can be used standalone or combined with other tools and frameworks. Web
119
12
        development is its principle use, but Cheetah is very flexible and is also being
120
13
        used to generate C++ game code, Java, sql, form emails and even Python code.
121
14
        
122
15
        Documentation
123
16
        ================================================================================
124
17
        For a high-level introduction to Cheetah please refer to the User's Guide
125
18
        at http://www.cheetahtemplate.org/learn.html
126
19
        
127
20
        Mailing list
128
21
        ================================================================================
129
22
        cheetahtemplate-discuss@lists.sourceforge.net
130
23
        Subscribe at http://lists.sourceforge.net/lists/listinfo/cheetahtemplate-discuss
131
24
        
132
25
        Credits
133
26
        ================================================================================
134
27
        http://www.cheetahtemplate.org/credits.html
135
28
        
136
29
        Recent Changes
137
30
        ================================================================================
138
31
        See http://www.cheetahtemplate.org/CHANGES.txt for full details
139
32
        
140
33
        
141
34
Platform: UNKNOWN
142
35
Classifier: Development Status :: 5 - Production/Stable
143
36
Classifier: Intended Audience :: Developers
144
37
Classifier: Intended Audience :: System Administrators
145
38
Classifier: License :: OSI Approved :: MIT License
146
39
Classifier: Operating System :: OS Independent
147
40
Classifier: Programming Language :: Python
148
41
Classifier: Topic :: Internet :: WWW/HTTP
149
42
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
150
43
Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
151
44
Classifier: Topic :: Software Development :: Code Generators
152
45
Classifier: Topic :: Software Development :: Libraries :: Python Modules
153
46
Classifier: Topic :: Software Development :: User Interfaces
154
47
Classifier: Topic :: Text Processing
155
0
48
156
=== added file 'Cheetah.egg-info/SOURCES.txt'
157
--- Cheetah.egg-info/SOURCES.txt	1970-01-01 00:00:00 +0000
158
+++ Cheetah.egg-info/SOURCES.txt	2010-10-19 20:12:51 +0000
159
@@ -0,0 +1,80 @@
160
1
CHANGES
161
2
LICENSE
162
3
MANIFEST.in
163
4
README.markdown
164
5
SetupConfig.py
165
6
SetupTools.py
166
7
TODO
167
8
setup.py
168
9
Cheetah.egg-info/PKG-INFO
169
10
Cheetah.egg-info/SOURCES.txt
170
11
Cheetah.egg-info/dependency_links.txt
171
12
Cheetah.egg-info/requires.txt
172
13
Cheetah.egg-info/top_level.txt
173
14
bin/cheetah
174
15
bin/cheetah-analyze
175
16
bin/cheetah-compile
176
17
cheetah/CacheRegion.py
177
18
cheetah/CacheStore.py
178
19
cheetah/CheetahWrapper.py
179
20
cheetah/Compiler.py
180
21
cheetah/DirectiveAnalyzer.py
181
22
cheetah/Django.py
182
23
cheetah/DummyTransaction.py
183
24
cheetah/ErrorCatchers.py
184
25
cheetah/FileUtils.py
185
26
cheetah/Filters.py
186
27
cheetah/ImportHooks.py
187
28
cheetah/ImportManager.py
188
29
cheetah/NameMapper.py
189
30
cheetah/Parser.py
190
31
cheetah/Servlet.py
191
32
cheetah/SettingsManager.py
192
33
cheetah/SourceReader.py
193
34
cheetah/Template.py
194
35
cheetah/TemplateCmdLineIface.py
195
36
cheetah/Unspecified.py
196
37
cheetah/Version.py
197
38
cheetah/__init__.py
198
39
cheetah/convertTmplPathToModuleName.py
199
40
cheetah/Macros/I18n.py
200
41
cheetah/Macros/__init__.py
201
42
cheetah/Templates/SkeletonPage.py
202
43
cheetah/Templates/SkeletonPage.tmpl
203
44
cheetah/Templates/_SkeletonPage.py
204
45
cheetah/Templates/__init__.py
205
46
cheetah/Tests/Analyzer.py
206
47
cheetah/Tests/CheetahWrapper.py
207
48
cheetah/Tests/Cheps.py
208
49
cheetah/Tests/Filters.py
209
50
cheetah/Tests/Misc.py
210
51
cheetah/Tests/NameMapper.py
211
52
cheetah/Tests/Parser.py
212
53
cheetah/Tests/Performance.py
213
54
cheetah/Tests/Regressions.py
214
55
cheetah/Tests/SyntaxAndOutput.py
215
56
cheetah/Tests/Template.py
216
57
cheetah/Tests/Test.py
217
58
cheetah/Tests/Unicode.py
218
59
cheetah/Tests/__init__.py
219
60
cheetah/Tests/xmlrunner.py
220
61
cheetah/Tools/CGITemplate.py
221
62
cheetah/Tools/MondoReport.py
222
63
cheetah/Tools/MondoReportDoc.txt
223
64
cheetah/Tools/RecursiveNull.py
224
65
cheetah/Tools/SiteHierarchy.py
225
66
cheetah/Tools/__init__.py
226
67
cheetah/Tools/turbocheetah/__init__.py
227
68
cheetah/Tools/turbocheetah/cheetahsupport.py
228
69
cheetah/Tools/turbocheetah/tests/__init__.py
229
70
cheetah/Tools/turbocheetah/tests/test_template.py
230
71
cheetah/Utils/Indenter.py
231
72
cheetah/Utils/Misc.py
232
73
cheetah/Utils/WebInputMixin.py
233
74
cheetah/Utils/__init__.py
234
75
cheetah/Utils/htmlDecode.py
235
76
cheetah/Utils/htmlEncode.py
236
77
cheetah/Utils/statprof.py
237
78
cheetah/c/Cheetah.h
238
79
cheetah/c/_namemapper.c
239
80
cheetah/c/cheetah.h
240
0
\ No newline at end of file
81
\ No newline at end of file
241
1
82
242
=== added file 'Cheetah.egg-info/dependency_links.txt'
243
--- Cheetah.egg-info/dependency_links.txt	1970-01-01 00:00:00 +0000
244
+++ Cheetah.egg-info/dependency_links.txt	2010-10-19 20:12:51 +0000
245
@@ -0,0 +1,1 @@
246
1
247
0
2
248
=== added file 'Cheetah.egg-info/requires.txt'
249
--- Cheetah.egg-info/requires.txt	1970-01-01 00:00:00 +0000
250
+++ Cheetah.egg-info/requires.txt	2010-10-19 20:12:51 +0000
251
@@ -0,0 +1,1 @@
252
1
Markdown >= 2.0.1
253
0
\ No newline at end of file
2
\ No newline at end of file
254
1
3
255
=== added file 'Cheetah.egg-info/top_level.txt'
256
--- Cheetah.egg-info/top_level.txt	1970-01-01 00:00:00 +0000
257
+++ Cheetah.egg-info/top_level.txt	2010-10-19 20:12:51 +0000
258
@@ -0,0 +1,1 @@
259
1
Cheetah
260
0
2
261
=== modified file 'MANIFEST.in'
262
--- MANIFEST.in	2006-07-26 22:03:15 +0000
263
+++ MANIFEST.in	2010-10-19 20:12:51 +0000
264
@@ -1,7 +1,7 @@
267
1
include MANIFEST.in *.py *.cfg TODO CHANGES LICENSE README examples docs bin
1
include MANIFEST.in *.py *.cfg TODO CHANGES LICENSE README.markdown examples docs bin
268
2
recursive-include src *.py *.tmpl *.txt
2
recursive-include cheetah *.py *.tmpl *.txt *.h
269
3
recursive-include bin *
3
recursive-include bin *
270
4
recursive-include docs * 
4
recursive-include docs * 
271
5
recursive-include examples *
5
recursive-include examples *
273
6
recursive-exclude src *.pyc *~ *.aux
6
recursive-exclude cheetah *.pyc *~ *.aux
274
7
recursive-exclude docs *~ *.aux
7
recursive-exclude docs *~ *.aux
275
8
8
276
=== modified file 'PKG-INFO'
277
--- PKG-INFO	2007-11-18 14:59:06 +0000
278
+++ PKG-INFO	2010-10-19 20:12:51 +0000
279
@@ -1,9 +1,9 @@
280
1
Metadata-Version: 1.0
1
Metadata-Version: 1.0
281
2
Name: Cheetah
2
Name: Cheetah
283
3
Version: 2.0.1
3
Version: 2.4.3
284
4
Summary: Cheetah is a template engine and code generation tool.
4
Summary: Cheetah is a template engine and code generation tool.
287
5
Home-page: http://www.CheetahTemplate.org/
5
Home-page: http://www.cheetahtemplate.org/
288
6
Author: Tavis Rudd
6
Author: R. Tyler Ballance
289
7
Author-email: cheetahtemplate-discuss@lists.sf.net
7
Author-email: cheetahtemplate-discuss@lists.sf.net
290
8
License: UNKNOWN
8
License: UNKNOWN
291
9
Description: Cheetah is an open source template engine and code generation tool.
9
Description: Cheetah is an open source template engine and code generation tool.
292
@@ -15,7 +15,7 @@
293
15
        Documentation
15
        Documentation
294
16
        ================================================================================
16
        ================================================================================
295
17
        For a high-level introduction to Cheetah please refer to the User's Guide
17
        For a high-level introduction to Cheetah please refer to the User's Guide
297
18
        at http://cheetahtemplate.org/learn.html
18
        at http://www.cheetahtemplate.org/learn.html
298
19
        
19
        
299
20
        Mailing list
20
        Mailing list
300
21
        ================================================================================
21
        ================================================================================
301
@@ -24,869 +24,12 @@
302
24
        
24
        
303
25
        Credits
25
        Credits
304
26
        ================================================================================
26
        ================================================================================
338
27
        http://cheetahtemplate.org/credits.html
27
        http://www.cheetahtemplate.org/credits.html
306
28
        
307
29
        Praise
308
30
        ================================================================================
309
31
        "I'm enamored with Cheetah" - Sam Ruby, senior member of IBM Emerging
310
32
        Technologies Group & director of Apache Software Foundation
311
33
        
312
34
        "Give Cheetah a try. You won't regret it. ... Cheetah is a truly powerful
313
35
        system. ... Cheetah is a serious contender for the 'best of breed' Python
314
36
        templating." - Alex Martelli
315
37
        
316
38
        "People with a strong PHP background absolutely love Cheetah for being Smarty,
317
39
        but much, much better." - Marek Baczynski
318
40
        
319
41
        "I am using Smarty and I know it very well, but compiled Cheetah Templates with
320
42
        its inheritance approach is much powerful and easier to use than Smarty." -
321
43
        Jaroslaw Zabiello
322
44
        
323
45
        "There is no better solution than Cheetah" - Wilk
324
46
        
325
47
        "A cheetah template can inherit from a python class, or a cheetah template, and
326
48
        a Python class can inherit from a cheetah template. This brings the full power
327
49
        of OO programming facilities to the templating system, and simply blows away
328
50
        other templating systems" - Mike Meyer
329
51
        
330
52
        "Cheetah has successfully been introduced as a replacement for the overweight
331
53
        XSL Templates for code generation. Despite the power of XSL (and notably XPath
332
54
        expressions), code generation is better suited to Cheetah as templates are much
333
55
        easier to implement and manage." - The FEAR development team
334
56
        (http://fear.sourceforge.net/docs/latest/guide/Build.html#id2550573)
335
57
        
336
58
        "I've used Cheetah quite a bit and it's a very good package" - Kevin Dangoor,
337
59
        lead developer of TurboGears.
339
60
        
28
        
340
61
        Recent Changes
29
        Recent Changes
341
62
        ================================================================================
30
        ================================================================================
1169
63
        See http://cheetahtemplate.org/docs/CHANGES for full details.
31
        See http://www.cheetahtemplate.org/CHANGES.txt for full details
1170
64
        
32
        
344
65
        Please initial your changes (there's a key at bottom) and add a date for each
345
66
        release
346
67
        ================================================================================
347
68
        
348
69
        2.0.1 (Nov 16, 2007)
349
70
        - fixed a deadlock Christoph Zwerschke found in Cheetah.ImportHooks.
350
71
        [TR]
351
72
        
352
73
        2.0 (Oct 12, 2007)
353
74
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
354
75
        
355
76
        - fixed exception handling issue in the C implemenation of NameMapper
356
77
        [patch from Eric Huss]
357
78
        
358
79
        - fixed filtering of #included subtemplates
359
80
        [patch from Brian Bird]
360
81
        
361
82
        See the release notes from 2.0b1-5 and 2.0rc1-8 for other changes since
362
83
        Cheetah 1.0.
363
84
        
364
85
        
365
86
        2.0rc8 (April 11, 2007)
366
87
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
367
88
        Core Changes: [TR]
368
89
        
369
90
        - added a '#unicode <encoding>' directive to indicate that the output of the
370
91
        template should be a unicode string even if the template source is a
371
92
        normal byte string.
372
93
        
373
94
        - #unicode and #encoding are mutually exclusive.  Use one or the other.
374
95
        - #unicode must be on a line by itself.
375
96
        - Strings in embedded code must be explictly marked as unicode if they
376
97
        contain non-ascii chars:
377
98
        
378
99
        #unicode latin-1
379
100
        $f(u"<some non-ascii char>") ## right
380
101
        $f("<some non-ascii char>") ## wrong
381
102
        
382
103
        However, this works fine:
383
104
        
384
105
        #unicode latin-1
385
106
        blah blah <some non-ascii char> blah blah
386
107
        
387
108
        - fixed several unicode bugs in the compiler.
388
109
        
389
110
        - fixed some unicode issues in the standard filters.
390
111
        
391
112
        - fixed a few minor bugs in code that never gets called.  Thanks to
392
113
        Alejandro Dubrovsky for pointing them out.
393
114
        
394
115
        - make RawOrEncodedUnicode the baseclass of all filters and remove some
395
116
        unused/redudant filters
396
117
        
397
118
        - added new compiler setting 'addTimestampsToCompilerOutput'. See Brian
398
119
        Bird's post about it.  He stores his cheetah generated .py files in
399
120
        subversion and needed to disable the timestamp code so svn wouldn't care
400
121
        when he recompiles those .py modules.
401
122
        
402
123
        - added the #super directive, which calls the method from the parent class
403
124
        which has the same as the current #def or #block method.
404
125
        
405
126
        #def foo
406
127
        ... child output
407
128
        #super  ## includes output of super(<CurrentClass>, self).foo()
408
129
        ... child output
409
130
        #end def
410
131
        
411
132
        
412
133
        #def bar(arg)
413
134
        ... child output
414
135
        #super(arg)  ## includes output of super(<CurrentClass>, self).bar(arg)
415
136
        ... child output
416
137
        #end def
417
138
        
418
139
        - added some unit tests for the new directives
419
140
        
420
141
        
421
142
        2.0rc7 (July 4, 2006)
422
143
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
423
144
        Core Changes: [TR]
424
145
        - extended the #implements directive so an arguments list can be declared in
425
146
        the same fashion as #def and #block.
426
147
        
427
148
        - made the parser raise ParseError when $*placeholder, $*5*placeholder,
428
149
        $(placeholder), etc. are found within expressions.  They are only valid in
429
150
        top-level text.
430
151
        
431
152
        - tweaked the parser so it's possible to place a comment on the same line as
432
153
        a directive without needing to explicitly close the directive first. This
433
154
        works regardless of whether or not you added a colon.
434
155
        
435
156
        self.verify("#if 1:\n$aStr\n#end if\n",
436
157
        "blarg\n")
437
158
        
438
159
        self.verify("#if 1:   \n$aStr\n#end if\n",
439
160
        "blarg\n")
440
161
        
441
162
        self.verify("#if 1: ##comment \n$aStr\n#end if\n",
442
163
        "blarg\n")
443
164
        
444
165
        self.verify("#if 1 ##comment \n$aStr\n#end if\n",
445
166
        "blarg\n")
446
167
        
447
168
        Previously, that last test would have required an extra # to close the #if
448
169
        directive before the comment directive started:
449
170
        self.verify("#if 1 ###comment \n$aStr\n#end if\n",
450
171
        "blarg\n")
451
172
        
452
173
        Code that makes use of explicit directive close tokens immediately followed by
453
174
        another directive will still work as expected:
454
175
        #if test##for i in range(10)# foo $i#end for##end if
455
176
        
456
177
        - safer handling of the baseclass arg to Template.compile().  It now does
457
178
        the right thing if the user passes in an instance rather than a class.
458
179
        
459
180
        ImportHooks: [TR]
460
181
        - made it possible to specify a list of template filename extentions that are
461
182
        looped through while searching for template modules. E.g.:
462
183
        import Cheetah.ImportHooks
463
184
        Cheetah.ImportHooks.install(templateFileExtensions=('.tmpl','.cheetah'))
464
185
        
465
186
        Core changes by MO:
466
187
        - Filters are now new-style classes.
467
188
        - WebSafe and the other optional filters in Filters.py now use
468
189
        RawOrEncodedUnicode instead of Filter as a base class.  This allows them
469
190
        to work with Unicode values containing non-ASCII characters.
470
191
        User-written custom filters should inherit from
471
192
        RawOrEncodedUnicode and call the superclass .filter() instead of str().
472
193
        str() as of Python 2.4.2 still converts Unicode to string using
473
194
        ASCII codec, which raises UnicodeEncodeError if it contains non-ASCII
474
195
        characters.
475
196
        
476
197
        2.0rc6 (Feb 4, 2006)
477
198
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
478
199
        Core Changes: [TR]
479
200
        - added a Cheetah version dependency check that raises an assertion if a
480
201
        template was compiled with a previous version of Cheetah whose templates
481
202
        must be recompiled.
482
203
        
483
204
        - made the Cheetah compilation metadata accessible via class attributes in
484
205
        addition to module globals
485
206
        
486
207
        - major improvement to exception reporting in cases where bad Python syntax
487
208
        slips past the Cheetah parser:
488
209
        """
489
210
        File "/usr/lib/python2.4/site-packages/Cheetah/Template.py", line 792, in compile
490
211
        raise parseError
491
212
        Cheetah.Parser.ParseError:
492
213
        
493
214
        Error in the Python code which Cheetah generated for this template:
494
215
        ================================================================================
495
216
        
496
217
        invalid syntax (DynamicallyCompiledCheetahTemplate.py, line 86)
497
218
        
498
219
        Line|Python Code
499
220
        ----|-------------------------------------------------------------
500
221
        84  |
501
222
        85  |        write('\n\n')
502
223
        86  |        for i an range(10): # generated from line 4, col 1
503
224
        ^
504
225
        87  |            _v = i # '$i' on line 5, col 3
505
226
        88  |            if _v is not None: write(_filter(_v, rawExpr='$i')) # from line 5, col 3.
506
227
        89  |            write('\n')
507
228
        
508
229
        ================================================================================
509
230
        
510
231
        Here is the corresponding Cheetah code:
511
232
        
512
233
        Line 4, column 1
513
234
        
514
235
        Line|Cheetah Code
515
236
        ----|-------------------------------------------------------------
516
237
        2   |#compiler useNameMapper=False
517
238
        3   |
518
239
        4   |#for i an range(10)
519
240
        ^
520
241
        5   |  $i
521
242
        6   |#end for
522
243
        7   |
523
244
        """
524
245
        
525
246
        2.0rc5 (Feb 3, 2006)
526
247
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
527
248
        Core Changes: [TR]
528
249
        - fixed a memory leak in Template.compile(), reported by Andrea Arcangeli
529
250
        - simplified concurrency locking and compile caching in Template.compile()
530
251
        
531
252
        The command line tool (CheetahWrapper.py):
532
253
        - added new option --settings for supplying compiler settings
533
254
        - added new option --templateAPIClass to replace the environment var
534
255
        CHEETAH_TEMPLATE_CLASS lookup I added in 2.0b1
535
256
        
536
257
        2.0rc4 (Jan 31, 2006)
537
258
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
538
259
        Core Changes: [TR]
539
260
        - fixed a typo-bug in the compile hashing code in Template.compile()
540
261
        - improved the macros framework and made it possible to implement macros in
541
262
        Python code so they can be shared between templates
542
263
        - more work on the #i18n directive.  It's now a macro directive.
543
264
        - added new Cheetah.Macros package
544
265
        - more tests
545
266
        
546
267
        2.0rc3 (Jan 29, 2006)
547
268
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
548
269
        Core Changes: [TR]
549
270
        - added short-form single line versions of all directives that have an #end
550
271
        tag, except for #errorCatcher:
551
272
        #if, #else, #elif, #unless,
552
273
        #for, #while, #repeat,
553
274
        #try, #except, #finally,
554
275
        #cache, #raw
555
276
        #call, #capture
556
277
        
557
278
        The #def and #block directives already had single-line versions.
558
279
        #if cond: foo
559
280
        #elif cond2: bar
560
281
        #else: blarg
561
282
        
562
283
        #for i, val in enumerate(vals): $i-$val
563
284
        
564
285
        Note that if you accidentally leave a colon at the end of one of these
565
286
        directives but nothing else follows it, aside from whitespace, the parser
566
287
        will treat it as a normal multi-line directive.
567
288
        
568
289
        The first leading space after the colon is discarded. Any additional
569
290
        spaces will be included in the output.
570
291
        
571
292
        Also note, if you use the short form versions of #if/#else/#elif you must
572
293
        it for all three.  The following is not valid:
573
294
        #if cond: foo
574
295
        #elif cond2
575
296
        bar
576
297
        #else: blarg
577
298
        
578
299
        - added support for $!silentModePlaceholders
579
300
        This is the same as quiet mode in Velocity:
580
301
        http://jakarta.apache.org/velocity/docs/user-guide.html#Quiet%20Reference%20Notation
581
302
        
582
303
        - added support for function/method @decorators.  It also works with blocks.
583
304
        As in vanilla Python, the @decorator statement must be followed with a
584
305
        function/method definition (i.e. #def or #block).
585
306
        
586
307
        #from xxx import aDecorator
587
308
        ...
588
309
        ...
589
310
        #@aDecorator
590
311
        #def func
591
312
        foo
592
313
        #end def
593
314
        
594
315
        #@aDecorator
595
316
        #def singleLineShortFormfunc: foo
596
317
        
597
318
        #@aDecorator
598
319
        #block func2
599
320
        bar
600
321
        #end block
601
322
        
602
323
        - added a new callback hook 'handlerForExtendsDirective' to the compiler settings. It
603
324
        can be used to customize the handling of #extends directives.  The
604
325
        callback can dynamically add import statements or rewrite the baseclass'
605
326
        name if needed:
606
327
        baseClassName = handler(compiler, baseClassName)
607
328
        See the discussion on the mailing list on Jan 25th for more details.
608
329
        
609
330
        - changed the default filter to the one that doesn't try to encode Unicode
610
331
        It was 'EncodeUnicode' and is now 'RawOrEncodedUnicode'.
611
332
        
612
333
        - added optional support for parsing whitespace between the directive start
613
334
        token (#) and directive names, per Christophe Eymard's request.  For the
614
335
        argument behind this see the mailing list archives for Jan 29th.  This is
615
336
        off by default.  You must turn it on using the compiler setting
616
337
        allowWhitespaceAfterDirectiveStartToken=True
617
338
        
618
339
        #for $something in $another
619
340
        #  for $somethin2 in $another2
620
341
        blahblah $something in $something2
621
342
        #  end for
622
343
        #end for
623
344
        
624
345
        - made the handling of Template.compile()'s preprocessors arg simpler and
625
346
        fixed a bug in it.
626
347
        
627
348
        - fixed attribute name bug in the .compile() method (it affected the feature
628
349
        that allows generated module files to be cached for better exception
629
350
        tracebacks)
630
351
        
631
352
        - refactored the #cache/CacheRegions code to support abitrary backend cache
632
353
        data stores.
633
354
        
634
355
        - added MemcachedCacheStore, which allows cache data to be stored in a
635
356
        memcached backend.  See http://www.linuxjournal.com/article/7451 and
636
357
        http://www.danga.com/memcached/.  This is only appropriate for systems
637
358
        running many Python server processes that need to share cached data to
638
359
        reduce memory requirements. Don't bother with this unless you actually
639
360
        need it. If you have a limited number of Python server processes it is
640
361
        much faster, simpler, and more secure to just cache in the memory of each
641
362
        process.
642
363
        
643
364
        KEEP MEMCACHED'S LIMITED SECURITY IN MIND!!  It has no authentication or
644
365
        encryption and will introduce a gaping hole in your defenses unless you
645
366
        are careful.  If you are caching sensitive data you should take measures
646
367
        to ensure that a) untrusted local system users cannot connect to memcached
647
368
        server, b) untrusted external servers cannot connect, and c) untrusted
648
369
        users on trusted external servers cannot connect.  Case (a) can be dealt
649
370
        with via iptable's owner match module for one way to do this: "iptables -A
650
371
        ... -m owner ..."  Cases (b) and (c) can be handled by tunnelling
651
372
        memcached network connections over stunnel and implementing stunnel
652
373
        authentication with mandatory peer/client certs.
653
374
        
654
375
        - some under-the-hood refactoring of the parser
655
376
        
656
377
        - made it possible to add custom directives, or customize the
657
378
        parsing/handling of existing ones, via the compiler settings
658
379
        'directiveNamesAndParsers' and 'endDirectiveNamesAndHandlers'
659
380
        
660
381
        - added a compile-time macro facility to Cheetah. These macros are very
661
382
        similar to macros in Lisp:
662
383
        http://www.apl.jhu.edu/~hall/Lisp-Notes/Macros.html.
663
384
        
664
385
        As with Lisp macros, they take source code (Cheetah source) as input and
665
386
        return source code (again Cheetah source) as output. They are executed at
666
387
        compile-time, just like in Lisp and C. The resultant code
667
388
        gets executed at run-time.
668
389
        
669
390
        The new #defmacro directive allows users to create macros inside the
670
391
        source of their templates.  Macros can also be provided via the compiler
671
392
        setting 'macroDirectives'. The 'macroDirectives' setting allows you to
672
393
        share common macros between templates.
673
394
        
674
395
        The syntax for the opening tag of #defmacro is the same as for #def and
675
396
        #block.  It expects a macro name followed by an optional argument list in
676
397
        brackets.  A `src` argument is automatically added to the beginning of
677
398
        every macro's argument list.  The value of the `src` is the block of
678
399
        input source code that is provided during a macro call (see below).
679
400
        
680
401
        #defmacro <macroname>[(argspec)]
681
402
        <macrobody>
682
403
        #end defmacro
683
404
        
684
405
        All of Cheetah's syntax is available for use inside macros, but the
685
406
        placeholderStartToken is @ instead of $ and the
686
407
        directiveStartToken/EndToken is % instead of #.  Any syntax using the
687
408
        standard $/# tokens will be treated as plain text and included in the output
688
409
        of the macro.
689
410
        
690
411
        Here are some examples:
691
412
        #defmacro addHeaderFooter
692
413
        header
693
414
        @src
694
415
        footer
695
416
        #end defmacro
696
417
        
697
418
        #defmacro addHeaderFooter(header='h', footer='f')
698
419
        @header
699
420
        @src
700
421
        @footer
701
422
        #end defmacro
702
423
        
703
424
        There is a single-line short form like for other directives:
704
425
        
705
426
        #defmacro addHeaderFooter: header @src footer
706
427
        #defmacro addHeaderFooter(header='h', footer='f'): @header @src @footer
707
428
        
708
429
        The syntax for calling a macro is similar to the simplest usage of the
709
430
        #call directive:
710
431
        
711
432
        #addHeaderFooter
712
433
        Source $code to wrap
713
434
        #end addHeaderFooter
714
435
        
715
436
        #addHeaderFooter: Source $code to wrap
716
437
        
717
438
        #addHeaderFooter header='header', footer='footer: Source $code to wrap
718
439
        
719
440
        
720
441
        In Elisp you write
721
442
        (defmacro inc (var)
722
443
        (list 'setq var (list '1+ var)))
723
444
        to define the macro `inc` and write
724
445
        (inc x)
725
446
        which expands to
726
447
        (setq x (1+ x))
727
448
        
728
449
        In Cheetah you'd write
729
450
        #defmacro inc: #set @src +=1
730
451
        #inc: $i
731
452
        which expands to
732
453
        #set $i += 1
733
454
        
734
455
        print Template("""\
735
456
        #defmacro inc: #set @src +=1
736
457
        #set i = 1
737
458
        #inc: $i
738
459
        $i""").strip()==2
739
460
        
740
461
        - fixed some bugs related to advanced usage of Template.compile(). These
741
462
        were found via new unit tests. No one had actually run into them yet.
742
463
        
743
464
        - added the initial bits of an #i18n directive.  It has the same semantics
744
465
        as
745
466
        #call self.handleI18n
746
467
        Some $var cheetah source
747
468
        #end call
748
469
        but has a simpler syntax:
749
470
        #i18n
750
471
        Some $var cheetah source
751
472
        #end i18n
752
473
        
753
474
        ## single-line short form:
754
475
        #i18n: Some $var cheetah source
755
476
        
756
477
        The method it calls, self.handleI18n, is just a stub at the moment, but it
757
478
        will soon be a wrapper around gettext.  It currently has one required
758
479
        positional argument `message`. I anticipate supporting the following
759
480
        optional arguments:
760
481
        
761
482
        id = msgid in the translation catalog
762
483
        domain = translation domain
763
484
        source = source lang
764
485
        target = a specific target lang
765
486
        comment = a comment to the translation team
766
487
        
767
488
        plural = the plural form of the message
768
489
        n = a sized argument to distinguish between single and plural forms
769
490
        
770
491
        #i18n is executed at runtime, but it can also be used in conjunction with
771
492
        a Cheetah preprocessor or macro (see above) to support compile time
772
493
        translation of strings that don't have to deal with plural forms.
773
494
        
774
495
        - added Cheetah.Utils.htmlEncode and Cheetah.Utils.htmlDecode
775
496
        
776
497
        - more docstring text
777
498
        
778
499
        Unit tests: [TR]
779
500
        - extended the caching tests
780
501
        - added tests for the various calling styles of Template.compile()
781
502
        - added copies of all the SyntaxAndOutput tests that use a template
782
503
        baseclass other than `Template`. This ensures that all syntax & core
783
504
        features work with 2.0's support for arbitrary baseclasses.
784
505
        - added tests for all the new directives and the new single-line short forms
785
506
        
786
507
        2.0rc2 (Jan 13th, 2006)
787
508
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
788
509
        Core Changes: [TR]
789
510
        - fixed some python 2.4isms that slipped in.  All the tests pass with Python
790
511
        2.2 now
791
512
        - added lots more docstring content in the Template class
792
513
        - made multiline comments gobble whitespace like other directives, per JJ's
793
514
        request.  The rather longwinded compiler setting
794
515
        gobbleWhitespaceAroundMultiLineComments can be used to go back to the old
795
516
        non-gobbling behaviour if needed.
796
517
        - added #capture directive to complement the #call directive.
797
518
        #call executes a region of Cheetah code and passes its output into a function call
798
519
        #capture executes a region of Cheetah code and assigns its output to a variable
799
520
        - extended the compile caching code in Template.compile so it works with the
800
521
        'file' arg.
801
522
        - added cacheModuleFilesForTracebacks and cacheDirForModuleFiles args to
802
523
        Template.compile(). See the docstring for details.
803
524
        - misc internal refactoring in the parser
804
525
        - improved handling of keyword args in the __init__ method and fixed a
805
526
        potential clash between the namespaces and searchList args
806
527
        
807
528
        WWW: [TR]
808
529
        - added the source for the new Cheetah website layout/content
809
530
        
810
531
        2.0rc1 (Jan 10, 2006)
811
532
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
812
533
        Core Changes: [TR]
813
534
        - made it possible nest #filter directives
814
535
        - added lots more docstring content in the Template class
815
536
        - added Template.subclass() classmethod for quickly creating subclasses of
816
537
        existing Cheetah template classes. It takes the same args as the
817
538
        .compile() classmethod and returns a template that is a subclass of the
818
539
        template .subclass() is called from:
819
540
        T1 = Template.compile(' foo - $meth1 - bar\n#def meth1: this is T1.meth1')
820
541
        T2 = T1.subclass('#implements meth1\n this is T2.meth1')
821
542
        
822
543
        - added baseclass arg to Template.compile(). It simplifies the reuse of
823
544
        dynamically compiled templates:
824
545
        # example 1, quickly subclassing a normal Python class and using its
825
546
        #  __init__ call signature:
826
547
        dictTemplate = Template.compile('hello $name from $caller', baseclass=dict)
827
548
        print dictTemplate(name='world', caller='me')
828
549
        
829
550
        # example 2, mixing a Cheetah method into a class definition:
830
551
        class Foo(dict):
831
552
        def meth1(self):
832
553
        return 'foo'
833
554
        def meth2(self):
834
555
        return 'bar'
835
556
        Foo = Template.compile('#implements meth3\nhello $name from $caller',
836
557
        baseclass=Foo)
837
558
        print Foo(name='world', caller='me')
838
559
        
839
560
        A side-benefit is the possibility to use the same Cheetah source with
840
561
        several baseclass, as the baseclass is orthogonal to the source code,
841
562
        unlike the #extends directive.
842
563
        
843
564
        - added 'namespaces' as an alias for 'searchList' in Template.__init__
844
565
        - made it possible to pass in a single namespace to 'searchList', which will
845
566
        automatically be converted into a list.
846
567
        - fixed issue with buffering and use of #call when template is used as a
847
568
        webkit servlet
848
569
        - added Cheetah.Utils.htmlEncode and htmlDecode
849
570
        
850
571
        The command line tool (CheetahWrapper.py):
851
572
        - changed insertion order for the --env and --pickle options so they match the
852
573
        commandline UI of the compiled template modules themselves [TR]
853
574
        
854
575
        2.0b5 (Jan 7, 2006)
855
576
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
856
577
        Core Changes: [TR]
857
578
        - made Cheetah.Template a new-style class by inserting 'object' into its'
858
579
        inheritance tree.  Templates can now use super(), properties and all the
859
580
        other goodies that come with new-style classes.
860
581
        - removed the WebInputMixin by placing its one method directly in the
861
582
        Template class.
862
583
        - removed the SettingsManager Mixin. It wasn't being used by anything
863
584
        anymore.
864
585
        - added a framework for caching the results of compilations in
865
586
        Template.compile().  This is on by default and protects against bad
866
587
        performance issues that are due to programmers misguidedly compiling
867
588
        templates inside tight loops.  It also saves on memory usage.
868
589
        - misc attr name changes to avoid namespace pollution
869
590
        - more + improved docstrings
870
591
        - replaced the oldstyle dynamic compile hacks with a wrapper around
871
592
        Template.compile().  The old usage pattern Template(src) now benefits from
872
593
        most of the recent changes.
873
594
        Template(src).__class__ == Template.compile(src)
874
595
        - removed all the extra imports required by oldstyle dynamic compile hacks
875
596
        - converted the cheetah #include mechanism to newstyle compilation and made it
876
597
        more flexible
877
598
        - made the #include mechanism work with file objects in addition to file names
878
599
        - made the handling of args to Template.compile() more flexible.  You can now
879
600
        provide defaults via class attributes.
880
601
        - made preprocessors for Template.compile() work with file arguments
881
602
        - added support for specifying a __metaclass__ on cheetah template classes
882
603
        - refactored both the class and instance initialization processes
883
604
        - improved the handling of __str__ in _assignRequiredMethodsToClass
884
605
        
885
606
        The command line tool (CheetahWrapper.py):  [TR]
886
607
        - improved error output in CheetahWrapper
887
608
        - switched fill command over to new style compile usage
888
609
        
889
610
        Unit tests: [TR]
890
611
        - fixed format string bug in unittest_local_copy.py
891
612
        
892
613
        2.0b4 (Jan 6, 2006)
893
614
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
894
615
        Core Changes: [TR]
895
616
        - fixed up parsing of target lists in for loops. This was previously limited
896
617
        to fairly simple target lists.
897
618
        #for ($i, $j) in [('aa','bb'),('cc','dd')]
898
619
        $i.upper,$j.upper
899
620
        #end for"
900
621
        #for (i, j) in [('aa','bb'),('cc','dd')]
901
622
        $i.upper,$j.upper
902
623
        #end for"
903
624
        #for i,(j, k) in enumerate([('aa','bb'),('cc','dd')])
904
625
        $j.upper,$k.upper
905
626
        #end for"
906
627
        - refactored the class initialization process
907
628
        - improved handling of target lists in #set directive. This was previously
908
629
        limited to fairly simple target lists.
909
630
        #set i,j = [1,2] ... #set $i,$j = [1,2]
910
631
        #set (i,j) = [1,2] ... #set ($i,$j) = [1,2]
911
632
        #set i, (j,k) = [1,(2,3)] ... #set $i, ($j,$k) = [1,(2,3)]
912
633
        
913
634
        - made it possible for the expressionFilter hooks to modify the code chunks
914
635
        they are fed. Also documented the hooks in a docstring.  Thus the hooks
915
636
        can be used as preprocessors for expressions, 'restricted execution', or
916
637
        even enforcement of style guidelines.
917
638
        
918
639
        - removed cheetah junk from docstrings and placed it all in comments or
919
640
        __moduleVars__. Per JJ's suggestion.
920
641
        
921
642
        - made it possible to nest #cache directives to any level
922
643
        - made it possible to nest #call directives to any level
923
644
        
924
645
        Unit Tests [TR]
925
646
        - extended tests for #for directive
926
647
        - expanded tests for #set directive
927
648
        - expanded tests for #call directive
928
649
        - expanded tests for #cache directive
929
650
        - added basic tests for the new $placeholder string expressions:
930
651
        c'text $placeholder text'
931
652
        
932
653
        2.0b3 (Jan 5, 2006)
933
654
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
934
655
        Core Changes: [TR]
935
656
        - added #yield statement
936
657
        - added ability to create nested scopes/functions via nested #def statements
937
658
        - added new #call directive and related #arg directive, per Ian Bicking's
938
659
        suggestion.
939
660
        - added new expression syntax c"text $placeholder text"
940
661
        
941
662
        for those basic function calling cases where you just need to pass in a
942
663
        small bit of cheetah output as an argument:
943
664
        
944
665
        c'a string with $placeholders',
945
666
        c'''a string with $placeholders''',
946
667
        c"a string with $placeholders",
947
668
        c"""a string with $placeholders"""
948
669
        
949
670
        - They can't contain #directives, but accept any valid $placeholder syntax
950
671
        except caching placeholders. Caching placeholders don't make any sense in
951
672
        this context.
952
673
        - They can be used *any* place where a python expression is expected.
953
674
        - They can be nested to any depth.
954
675
        
955
676
        $func(c'<li>$var1-$var2</li>')
956
677
        $func(c'<li>$var1-$var2</li>', doSomething=True)
957
678
        $func(content=c'<li>$var1-$var2</li>', doSomething=True)
958
679
        $func(lambda x,y: c'<li>$x-$y</li>')
959
680
        $func(callback=lambda x,y: c'<li>$x-$y</li>')
960
681
        $func(lambda x,y: c'<li>$x-$y-$varInSearchList</li>')
961
682
        $func(c'<li>$var1-$var2-$(var3*10)-$(94.3*58)</li>')
962
683
        $func(c'<li>$var1-$var2-$func2(c"a nested expr $var99")</li>')
963
684
        #if $cond then c'<li>$var1-$var2</li>' else c'<p>$var1-$var2</p>'
964
685
        #def foo(arg1=c'$var1<span class="foo">$var2</span>'):  blah $arg1 blah
965
686
        $foo(c'$var1<i>$var2</i>')
966
687
        
967
688
        - added preprocessor hooks to Template.compile()
968
689
        can be used for partial completion or 'compile-time-caching'
969
690
        ... more details and examples coming.  It's very useful, but takes a bit
970
691
        of explaining.
971
692
        - added '#set module varName = expr' for adding module globals. JJ's suggestion
972
693
        - improved generated docstring notes about cached vars
973
694
        - fixed silly bug related to """ in docstring comments and statements like
974
695
        this '#def foo: $str("""foo""")'.  Reported by JJ.
975
696
        - changed the handling of single-line defs so that
976
697
        '#def xxx:<just whitespace>\n' will be treated as a multi-line #def.
977
698
        The same applies to #block.  There's a compiler setting to turn this off
978
699
        if you really need empty single-line #def:'s.
979
700
        JJ reported that this was causing great confusion with beginners.
980
701
        - improved error message for unclosed directives, per Mike Orr's suggestion.
981
702
        - added optional support for passing the trans arg to methods via **KWS rather
982
703
        than trans=None.  See the discussion on the mailing list Jan 4th (JJ's post) for
983
704
        details.  The purpose is to avoid a positional argument clash that
984
705
        apparently is very confusing for beginners.
985
706
        
986
707
        Note that any existing client code that passing the trans arg in
987
708
        positionally rather than as a keyword will break as a result.  WebKit
988
709
        does this with the .respond method so I've kept the old style there.
989
710
        You can also turn this new behaviour off by either manually including
990
711
        the trans arg in your method signature (see the example below) or by
991
712
        using the compiler setting 'useKWsDictArgForPassingTrans'=False.
992
713
        
993
714
        #def manualOverride(arg1, trans=None)
994
715
        foo $arg1
995
716
        #end def
996
717
        
997
718
        ImportHooks:
998
719
        - made the ImportHook more robust against compilation errors during import [TR]
999
720
        
1000
721
        Install scripts: [TR]
1001
722
        - added optional support for pje's setuptools
1002
723
        - added cheeseshop classifiers
1003
724
        - removed out of date install instructions in __init__.py
1004
725
        
1005
726
        Servlet Base Class For Webkit: [TR]
1006
727
        - disabled assignment of self.application (was a webware hack)
1007
728
        
1008
729
        Unit Tests: [TR]
1009
730
        - unit tests for most of the new syntax elements
1010
731
        - tidied up some old tests
1011
732
        - misc refactoring
1012
733
        
1013
734
        2.0b2 (Dec 30, 2005)
1014
735
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
1015
736
        
1016
737
        Core Changes:
1017
738
        - In previous versions of Cheetah tracebacks from exceptions that were raised
1018
739
        inside dynamically compiled Cheetah templates were opaque because
1019
740
        Python didn't have access to a python source file to use in the traceback:
1020
741
        
1021
742
        File "xxxx.py", line 192, in getTextiledContent
1022
743
        content = str(template(searchList=searchList))
1023
744
        File "cheetah_yyyy.py", line 202, in __str__
1024
745
        File "cheetah_yyyy.py", line 187, in respond
1025
746
        File "cheetah_yyyy.py", line 139, in writeBody
1026
747
        ZeroDivisionError: integer division or modulo by zero
1027
748
        
1028
749
        It is now possible to keep the generated source code from the python
1029
750
        classes returned by Template.compile() in a cache dir.  Having these files
1030
751
        around allows Python to include the actual source lines in tracebacks and
1031
752
        makes them much easier to understand:
1032
753
        
1033
754
        File "/usr/local/unsnarl/lib/python/us/ui/views/WikiPageRenderer.py", line 192, in getTextiledContent
1034
755
        content = str(template(searchList=searchList))
1035
756
        File "/tmp/CheetahCacheDir/cheetah_yyyy.py", line 202, in __str__
1036
757
        def __str__(self): return self.respond()
1037
758
        File "/tmp/CheetahCacheDir/cheetah_yyyy.py", line 187, in respond
1038
759
        self.writeBody(trans=trans)
1039
760
        File "/tmp/CheetahCacheDir/cheetah_yyyy.py", line 139, in writeBody
1040
761
        __v = 0/0 # $(0/0)
1041
762
        ZeroDivisionError: integer division or modulo by zero
1042
763
        
1043
764
        This is turned off by default. To turn it on, do this:
1044
765
        
1045
766
        class NiceTracebackTemplate(Template):
1046
767
        _CHEETAH_cacheModuleFilesForTracebacks = True
1047
768
        _CHEETAH_cacheDirForModuleFiles = '/tmp/CheetahCacheDir' # change to a dirname
1048
769
        
1049
770
        templateClass = NiceTracebackTemplate.compile(src)
1050
771
        
1051
772
        # or
1052
773
        templateClass = Template.compile(src,
1053
774
        cacheModuleFilesForTracebacks=True, cacheDirForModuleFiles='/tmp/CheetahCacheDir')
1054
775
        
1055
776
        
1056
777
        This only works with the new Template.compile(src) usage style!
1057
778
        
1058
779
        Note, Cheetah generated modules that are compiled on the command line have
1059
780
        never been affected by this issue. [TR]
1060
781
        
1061
782
        - added an extra comment per $placeholder to generated python code so it is
1062
783
        easier to grok. [TR]
1063
784
        
1064
785
        2.0b1 (Dec 29, 2005)
1065
786
        !!!THIS RELEASE REQUIRES RECOMPILATION OF ALL COMPILED CHEETAH TEMPLATES!!!
1066
787
        
1067
788
        Core Changes:
1068
789
        - enabled use of any expression in ${placeholders}. See the examples I posted to
1069
790
        the email list on Dec 12th.  All use cases of the #echo directive can now
1070
791
        be handled with ${placeholders}.  This came from a suggestion by Mike
1071
792
        Orr. [TR]
1072
793
        
1073
794
        - made it possible for templates to #extend (aka subclass) any arbitrary
1074
795
        baseclass, including Python's new style classes.  You must either compile
1075
796
        your classes on the command line or use the new classmethod
1076
797
        Template.compile() as described below.  The old Template(src) interface
1077
798
        still works, provided you don't try to use this new arbitrary baseclass
1078
799
        stuff.  See my messages to the email list for more details. [TR]
1079
800
        
1080
801
        - made it possible to create template classes dynamically, rather than just
1081
802
        instances.  See the new classmethod Template.compile().  See my messages
1082
803
        to the email list for more details. [TR]
1083
804
        
1084
805
        klass = Template.compile(src)
1085
806
        
1086
807
        - made it easier to work with custom compiler settings, particularly from
1087
808
        the command line tool.  You can now define a subclass of Template which
1088
809
        will compile your templates using custom compilerSettings, or even a
1089
810
        custom compiler class, without requiring you to manually pass in your
1090
811
        compilerSettings each time or define them in the template src itself via
1091
812
        the #compiler directive.  You can make the command line tool use your
1092
813
        subclass by defining the environment variable CHEETAH_TEMPLATE_CLASS.  It
1093
814
        should be in the form 'package.module:class'.  See my messages
1094
815
        to the email list for more details. [TR]
1095
816
        
1096
817
        - made it possible to pass the searchList in as an argument to #def'ined
1097
818
        methods.  This makes all lookup that occur within the scope of that method
1098
819
        use the provided searchList rather than self._searchList.  This does not
1099
820
        carry over to other methods called within the top method, unless they
1100
821
        explicitly accept the searchList in their signature AND you pass it to
1101
822
        them when calling them.  This behaviour can be turned off with the
1102
823
        corresponding compilerSetting 'allowSearchListAsMethArg' [TR]
1103
824
        
1104
825
        - added hooks for filtering / restricting dangerous stuff in cheetah source
1105
826
        code at compile time.  These hooks can be used to enable Cheetah template
1106
827
        authoring by untrusted users. See my messages to the email list for more
1107
828
        details. Note, it filters expressions at parse/compile time, unlike Python's
1108
829
        old rexec module which restricted the Python environment at runtime. [TR]
1109
830
        
1110
831
        # Here are the relevant compiler settings:
1111
832
        # use lower case keys here!!
1112
833
        'disabledDirectives':[], # list of directive keys, without the start token
1113
834
        'enabledDirectives':[], # list of directive keys, without the start token
1114
835
        
1115
836
        'disabledDirectiveHooks':[], # callable(parser, directiveKey),
1116
837
        # called when a disabled directive is found, prior to raising an exception
1117
838
        
1118
839
        'preparseDirectiveHooks':[], # callable(parser, directiveKey)
1119
840
        'postparseDirectiveHooks':[], # callable(parser, directiveKey)
1120
841
        
1121
842
        'preparsePlaceholderHooks':[], # callable(parser)
1122
843
        'postparsePlaceholderHooks':[], # callable(parser)
1123
844
        
1124
845
        'expressionFilterHooks':[],
1125
846
        # callable(parser, expr, exprType, rawExpr=None, startPos=None)
1126
847
        # exprType is the name of the directive, 'psp', or 'placeholder'.
1127
848
        #all lowercase
1128
849
        
1129
850
        - added support for a short EOLSlurpToken to supplement the #slurp
1130
851
        directive.  It's currently re.compile('#\s*\n') (i.e # followed by
1131
852
        arbitrary whitespace and a new line), but this is not set in stone.  One
1132
853
        other suggestion was the backslash char, but I believe Python's own
1133
854
        interpretation of backslashes will lead to confusion.  The compiler
1134
855
        setting 'EOLSlurpToken' controls this.  You can turn it off completely by
1135
856
        setting 'EOLSlurpToken' to None. See the email list for more details. [TR]
1136
857
        
1137
858
        - added '_CHEETAH_' prefix to all instance attribute names in compiled
1138
859
        templates. This is related to the arbitrary baseclass change. [TR]
1139
860
        
1140
861
        - shifted instance attribute setup to _initCheetahAttributes() method.  This
1141
862
        is related to the arbitrary baseclass change. [TR]
1142
863
        
1143
864
        - made it possible to use full expressions in the #extends directive, rather
1144
865
        than just dotted names. This allows you to do things like this:
1145
866
        
1146
867
        #from xx.TemplateRepository import getTemplateClass
1147
868
        #extends getTemplateClass('someName')
1148
869
        
1149
870
        I don't expect this to be used much. I needed it for a wiki system in
1150
871
        which the baseclasses for the templates are dynamically compiled at run
1151
872
        time and are not available via simple imports. [TR]
1152
873
        
1153
874
        - added compiler setting autoImportForExtendDirective=True, so this existing
1154
875
        default behaviour can be turned off when needed. [TR]
1155
876
        
1156
877
        - fixed a bug in the parsing of single-line #def's and #block's when they
1157
878
        are enclosed within #if ... #end if. Reported by Marcin Gajda [TR]
1158
879
        
1159
880
        - tweak to remove needless write('') calls in generated code [TR]
1160
881
        
1161
882
        The command line tool (CheetahWrapper.py):
1162
883
        - added code to cleanup trailing slashes on path arguments (code originally
1163
884
        from Mike Orr) [TR]
1164
885
        - turned on the ImportHooks by default for the 'cheetah fill' command. See the
1165
886
        discussion on the email list [TR]
1166
887
        
1167
888
        ImportHooks:
1168
889
        - fixed a name error bug in the ImportHooks [TR]
1171
890
        
33
        
1172
891
Platform: UNKNOWN
34
Platform: UNKNOWN
1173
892
Classifier: Development Status :: 5 - Production/Stable
35
Classifier: Development Status :: 5 - Production/Stable
1174
893
36
1175
=== removed file 'README'
1176
--- README	2006-07-26 22:03:15 +0000
1177
+++ README	1970-01-01 00:00:00 +0000
1178
@@ -1,51 +0,0 @@
1179
1
Cheetah is an open source template engine and code generation tool.
1180
2
1181
3
It can be used standalone or combined with other tools and frameworks. Web
1182
4
development is its principle use, but Cheetah is very flexible and is also being
1183
5
used to generate C++ game code, Java, sql, form emails and even Python code.
1184
6
1185
7
Documentation
1186
8
================================================================================
1187
9
For a high-level introduction to Cheetah please refer to the User\'s Guide
1188
10
at http://cheetahtemplate.org/learn.html
1189
11
1190
12
Mailing list
1191
13
================================================================================
1192
14
cheetahtemplate-discuss@lists.sourceforge.net
1193
15
Subscribe at http://lists.sourceforge.net/lists/listinfo/cheetahtemplate-discuss
1194
16
1195
17
Credits
1196
18
================================================================================
1197
19
http://cheetahtemplate.org/credits.html
1198
20
1199
21
Praise
1200
22
================================================================================
1201
23
"I\'m enamored with Cheetah" - Sam Ruby, senior member of IBM Emerging
1202
24
Technologies Group & director of Apache Software Foundation
1203
25
1204
26
"Give Cheetah a try. You won\'t regret it. ... Cheetah is a truly powerful
1205
27
system. ... Cheetah is a serious contender for the 'best of breed' Python
1206
28
templating." - Alex Martelli
1207
29
1208
30
"People with a strong PHP background absolutely love Cheetah for being Smarty,
1209
31
but much, much better." - Marek Baczynski
1210
32
1211
33
"I am using Smarty and I know it very well, but compiled Cheetah Templates with
1212
34
its inheritance approach is much powerful and easier to use than Smarty." -
1213
35
Jaroslaw Zabiello
1214
36
1215
37
"There is no better solution than Cheetah" - Wilk
1216
38
1217
39
"A cheetah template can inherit from a python class, or a cheetah template, and
1218
40
a Python class can inherit from a cheetah template. This brings the full power
1219
41
of OO programming facilities to the templating system, and simply blows away
1220
42
other templating systems" - Mike Meyer
1221
43
1222
44
"Cheetah has successfully been introduced as a replacement for the overweight
1223
45
XSL Templates for code generation. Despite the power of XSL (and notably XPath
1224
46
expressions), code generation is better suited to Cheetah as templates are much
1225
47
easier to implement and manage." - The FEAR development team
1226
48
    (http://fear.sourceforge.net/docs/latest/guide/Build.html#id2550573)
1227
49
1228
50
"I\'ve used Cheetah quite a bit and it\'s a very good package" - Kevin Dangoor,
1229
51
lead developer of TurboGears.
1230
52
0
1231
=== added file 'README.markdown'
1232
--- README.markdown	1970-01-01 00:00:00 +0000
1233
+++ README.markdown	2010-10-19 20:12:51 +0000
1234
@@ -0,0 +1,51 @@
1235
1
Cheetah is an open source template engine and code generation tool.
1236
2
1237
3
It can be used standalone or combined with other tools and frameworks. Web
1238
4
development is its principle use, but Cheetah is very flexible and is also being
1239
5
used to generate C++ game code, Java, sql, form emails and even Python code.
1240
6
1241
7
Documentation
1242
8
================================================================================
1243
9
For a high-level introduction to Cheetah please refer to the User\'s Guide
1244
10
at http://cheetahtemplate.org/learn.html
1245
11
1246
12
Mailing list
1247
13
================================================================================
1248
14
cheetahtemplate-discuss@lists.sourceforge.net
1249
15
Subscribe at http://lists.sourceforge.net/lists/listinfo/cheetahtemplate-discuss
1250
16
1251
17
Credits
1252
18
================================================================================
1253
19
http://cheetahtemplate.org/credits.html
1254
20
1255
21
Praise
1256
22
================================================================================
1257
23
"I\'m enamored with Cheetah" - Sam Ruby, senior member of IBM Emerging
1258
24
Technologies Group & director of Apache Software Foundation
1259
25
1260
26
"Give Cheetah a try. You won\'t regret it. ... Cheetah is a truly powerful
1261
27
system. ... Cheetah is a serious contender for the 'best of breed' Python
1262
28
templating." - Alex Martelli
1263
29
1264
30
"People with a strong PHP background absolutely love Cheetah for being Smarty,
1265
31
but much, much better." - Marek Baczynski
1266
32
1267
33
"I am using Smarty and I know it very well, but compiled Cheetah Templates with
1268
34
its inheritance approach is much powerful and easier to use than Smarty." -
1269
35
Jaroslaw Zabiello
1270
36
1271
37
"There is no better solution than Cheetah" - Wilk
1272
38
1273
39
"A cheetah template can inherit from a python class, or a cheetah template, and
1274
40
a Python class can inherit from a cheetah template. This brings the full power
1275
41
of OO programming facilities to the templating system, and simply blows away
1276
42
other templating systems" - Mike Meyer
1277
43
1278
44
"Cheetah has successfully been introduced as a replacement for the overweight
1279
45
XSL Templates for code generation. Despite the power of XSL (and notably XPath
1280
46
expressions), code generation is better suited to Cheetah as templates are much
1281
47
easier to implement and manage." - The FEAR development team
1282
48
    (http://fear.sourceforge.net/docs/latest/guide/Build.html#id2550573)
1283
49
1284
50
"I\'ve used Cheetah quite a bit and it\'s a very good package" - Kevin Dangoor,
1285
51
lead developer of TurboGears.
1286
0
52
1287
=== modified file 'SetupConfig.py'
1288
--- SetupConfig.py	2006-07-26 22:03:15 +0000
1289
+++ SetupConfig.py	2010-10-19 20:12:51 +0000
1290
@@ -1,17 +1,18 @@
1291
1
#-------Main Package Settings-----------#
1
#-------Main Package Settings-----------#
1295
2
name = "Cheetah"
2
import sys
1296
3
from src.Version import Version as version
3
1297
4
maintainer = "Tavis Rudd"
4
name = 'Cheetah'
1298
5
from cheetah.Version import Version as version
1299
6
maintainer = "R. Tyler Ballance"
1300
5
author = "Tavis Rudd"
7
author = "Tavis Rudd"
1301
6
author_email = "cheetahtemplate-discuss@lists.sf.net"
8
author_email = "cheetahtemplate-discuss@lists.sf.net"
1303
7
url = "http://www.CheetahTemplate.org/"
9
url = "http://www.cheetahtemplate.org/"
1304
8
packages = ['Cheetah',
10
packages = ['Cheetah',
1305
9
            'Cheetah.Macros',            
11
            'Cheetah.Macros',            
1306
10
            'Cheetah.Templates',
12
            'Cheetah.Templates',
1307
11
            'Cheetah.Tests',
13
            'Cheetah.Tests',
1308
12
            'Cheetah.Tools',
14
            'Cheetah.Tools',
1309
13
            'Cheetah.Utils',
15
            'Cheetah.Utils',
1310
14
	    'Cheetah.Utils.optik',
1311
15
            ]
16
            ]
1312
16
classifiers = [line.strip() for line in '''\
17
classifiers = [line.strip() for line in '''\
1313
17
  #Development Status :: 4 - Beta
18
  #Development Status :: 4 - Beta
1314
@@ -28,30 +29,50 @@
1315
28
  Topic :: Software Development :: Libraries :: Python Modules
29
  Topic :: Software Development :: Libraries :: Python Modules
1316
29
  Topic :: Software Development :: User Interfaces
30
  Topic :: Software Development :: User Interfaces
1317
30
  Topic :: Text Processing'''.splitlines() if not line.strip().startswith('#')]
31
  Topic :: Text Processing'''.splitlines() if not line.strip().startswith('#')]
1318
31
del line
1319
32
32
1321
33
package_dir = {'Cheetah':'src'}
33
package_dir = {'Cheetah':'cheetah'}
1322
34
34
1323
35
import os
35
import os
1324
36
import os.path
36
import os.path
1325
37
from distutils.core import Extension
37
from distutils.core import Extension
1326
38
38
1336
39
## we only assume the presence of a c compiler on Posix systems, NT people will
39
ext_modules=[
1337
40
#  have to enable this manually. 
40
             Extension("Cheetah._namemapper", 
1338
41
if os.name == 'posix':
41
                        [os.path.join('cheetah', 'c', '_namemapper.c')]),
1339
42
    ext_modules=[Extension("Cheetah._namemapper", [os.path.join("src" ,"_namemapper.c")]
42
           #  Extension("Cheetah._verifytype", 
1340
43
                           )
43
           #             [os.path.join('cheetah', 'c', '_verifytype.c')]),
1341
44
                 ]
44
           #  Extension("Cheetah._filters", 
1342
45
else:
45
           #             [os.path.join('cheetah', 'c', '_filters.c')]),
1343
46
    ext_modules=[]
46
           #  Extension('Cheetah._template',
1344
47
47
           #             [os.path.join('cheetah', 'c', '_template.c')]),
1345
48
             ]
1346
48
49
1347
49
## Data Files and Scripts
50
## Data Files and Scripts
1349
50
scripts = ['bin/cheetah-compile',
51
scripts = ('bin/cheetah-compile',
1350
51
           'bin/cheetah',
52
           'bin/cheetah',
1354
52
           ]
53
           'bin/cheetah-analyze',
1355
53
data_files = ['recursive: src *.tmpl *.txt LICENSE README TODO CHANGES',
54
        )
1356
54
              ]
55
1357
56
data_files = ['recursive: cheetah *.tmpl *.txt LICENSE README TODO CHANGES',]
1358
57
1359
58
if not os.getenv('CHEETAH_INSTALL_WITHOUT_SETUPTOOLS'):
1360
59
    try:
1361
60
        from setuptools import setup
1362
61
        install_requires = [
1363
62
                "Markdown >= 2.0.1",
1364
63
        ]
1365
64
        if sys.platform == 'win32':
1366
65
            # use 'entry_points' instead of 'scripts'
1367
66
            del scripts
1368
67
            entry_points = {
1369
68
                'console_scripts': [
1370
69
                    'cheetah = Cheetah.CheetahWrapper:_cheetah',
1371
70
                    'cheetah-compile = Cheetah.CheetahWrapper:_cheetah_compile',
1372
71
                ]
1373
72
        }
1374
73
    except ImportError:
1375
74
        print('Not using setuptools, so we cannot install the Markdown dependency')
1376
75
1377
55
76
1378
56
description = "Cheetah is a template engine and code generation tool."
77
description = "Cheetah is a template engine and code generation tool."
1379
57
78
1380
@@ -64,7 +85,7 @@
1381
64
Documentation
85
Documentation
1382
65
================================================================================
86
================================================================================
1383
66
For a high-level introduction to Cheetah please refer to the User\'s Guide
87
For a high-level introduction to Cheetah please refer to the User\'s Guide
1385
67
at http://cheetahtemplate.org/learn.html
88
at http://www.cheetahtemplate.org/learn.html
1386
68
89
1387
69
Mailing list
90
Mailing list
1388
70
================================================================================
91
================================================================================
1389
@@ -73,48 +94,10 @@
1390
73
94
1391
74
Credits
95
Credits
1392
75
================================================================================
96
================================================================================
1426
76
http://cheetahtemplate.org/credits.html
97
http://www.cheetahtemplate.org/credits.html
1394
77
1395
78
Praise
1396
79
================================================================================
1397
80
"I\'m enamored with Cheetah" - Sam Ruby, senior member of IBM Emerging
1398
81
Technologies Group & director of Apache Software Foundation
1399
82
1400
83
"Give Cheetah a try. You won\'t regret it. ... Cheetah is a truly powerful
1401
84
system. ... Cheetah is a serious contender for the 'best of breed' Python
1402
85
templating." - Alex Martelli
1403
86
1404
87
"People with a strong PHP background absolutely love Cheetah for being Smarty,
1405
88
but much, much better." - Marek Baczynski
1406
89
1407
90
"I am using Smarty and I know it very well, but compiled Cheetah Templates with
1408
91
its inheritance approach is much powerful and easier to use than Smarty." -
1409
92
Jaroslaw Zabiello
1410
93
1411
94
"There is no better solution than Cheetah" - Wilk
1412
95
1413
96
"A cheetah template can inherit from a python class, or a cheetah template, and
1414
97
a Python class can inherit from a cheetah template. This brings the full power
1415
98
of OO programming facilities to the templating system, and simply blows away
1416
99
other templating systems" - Mike Meyer
1417
100
1418
101
"Cheetah has successfully been introduced as a replacement for the overweight
1419
102
XSL Templates for code generation. Despite the power of XSL (and notably XPath
1420
103
expressions), code generation is better suited to Cheetah as templates are much
1421
104
easier to implement and manage." - The FEAR development team
1422
105
    (http://fear.sourceforge.net/docs/latest/guide/Build.html#id2550573)
1423
106
1424
107
"I\'ve used Cheetah quite a bit and it\'s a very good package" - Kevin Dangoor,
1425
108
lead developer of TurboGears.
1427
109
98
1428
110
Recent Changes
99
Recent Changes
1429
111
================================================================================
100
================================================================================
1431
112
See http://cheetahtemplate.org/docs/CHANGES for full details.
101
See http://www.cheetahtemplate.org/CHANGES.txt for full details
1432
113
102
1433
114
'''
103
'''
1434
115
try:
1435
116
    recentChanges = open('CHANGES').read().split('\n1.0')[0]
1436
117
    long_description += recentChanges
1437
118
    del recentChanges
1438
119
except:
1439
120
    pass
1440
121
104
1441
=== modified file 'SetupTools.py'
1442
--- SetupTools.py	2007-11-18 14:59:06 +0000
1443
+++ SetupTools.py	2010-10-19 20:12:51 +0000
1444
@@ -1,44 +1,61 @@
1445
1
#!/usr/bin/env python
1
#!/usr/bin/env python
1446
2
# $Id: SetupTools.py,v 1.9 2007/11/03 19:44:38 tavis_rudd Exp $
1447
3
"""Some tools for extending and working with distutils
1448
4
1449
5
CREDITS: This module borrows code and ideas from M.A. Lemburg's excellent setup
1450
6
tools for the mxBase package.
1451
7
1452
8
"""
1453
9
1454
10
__author__ = "Tavis Rudd <tavis@damnsimple.com>"
1455
11
__version__ = "$Revision: 1.9 $"[11:-2]
1456
12
1457
13
import os
2
import os
1458
14
from os import listdir
3
from os import listdir
1459
15
import os.path
4
import os.path
1460
16
from os.path import exists, isdir, isfile, join, splitext
5
from os.path import exists, isdir, isfile, join, splitext
1461
6
import sys
1462
17
import types
7
import types
1463
18
import glob
8
import glob
1464
19
import string
9
import string
1465
20
import traceback
10
import traceback
1466
21
11
1467
22
from distutils.core import setup
12
from distutils.core import setup
1472
23
if 'CHEETAH_USE_SETUPTOOLS' in os.environ:
13
if not os.getenv('CHEETAH_INSTALL_WITHOUT_SETUPTOOLS'):
1469
24
    # @@TR: Please note that this is for testing purposes only!  PEAK setuptools
1470
25
    # is not required or recommended for installing Cheetah.  Downstream
1471
26
    # package managers (linux distros, etc.) should *not* enable this.
1473
27
    try:
14
    try:
1474
28
        # use http://peak.telecommunity.com/DevCenter/setuptools if it's installed
1475
29
        # requires Py >=2.3
1476
30
        from setuptools import setup
15
        from setuptools import setup
1477
31
    except ImportError:   
16
    except ImportError:   
1478
32
        from distutils.core import setup
17
        from distutils.core import setup
1479
33
18
1480
34
from distutils.core import Command
19
from distutils.core import Command
1481
20
from distutils.command.build_ext import build_ext
1482
35
from distutils.command.install_data import install_data
21
from distutils.command.install_data import install_data
1483
22
from distutils.errors import CCompilerError, DistutilsExecError, \
1484
23
    DistutilsPlatformError
1485
36
24
1486
37
#imports from Cheetah ...
25
#imports from Cheetah ...
1488
38
from src.FileUtils import findFiles
26
from cheetah.FileUtils import findFiles
1489
27
1490
28
if sys.platform == 'win32' and sys.version_info > (2, 6):
1491
29
   # 2.6's distutils.msvc9compiler can raise an IOError when failing to
1492
30
   # find the compiler
1493
31
   ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError,
1494
32
                 IOError)
1495
33
else:
1496
34
   ext_errors = (CCompilerError, DistutilsExecError, DistutilsPlatformError)
1497
39
35
1498
40
##################################################
36
##################################################
1499
41
## CLASSES ##
37
## CLASSES ##
1500
38
1501
39
class BuildFailed(Exception):
1502
40
    pass
1503
41
1504
42
class mod_build_ext(build_ext):
1505
43
    """A modified version of the distutils build_ext command that raises an
1506
44
    exception when building of the extension fails.
1507
45
    """
1508
46
1509
47
    def run(self):
1510
48
        try:
1511
49
            build_ext.run(self)
1512
50
        except DistutilsPlatformError, x:
1513
51
            raise BuildFailed(x)
1514
52
1515
53
    def build_extension(self, ext):
1516
54
        try:
1517
55
            build_ext.build_extension(self, ext)
1518
56
        except ext_errors, x:
1519
57
            raise BuildFailed(x)
1520
58
1521
42
   
59
   
1522
43
class mod_install_data(install_data):
60
class mod_install_data(install_data):
1523
44
    """A modified version of the disutils install_data command that allows data
61
    """A modified version of the disutils install_data command that allows data
1524
@@ -60,8 +77,8 @@
1525
60
        data_files = self.get_inputs()
77
        data_files = self.get_inputs()
1526
61
        
78
        
1527
62
        for entry in data_files:
79
        for entry in data_files:
1530
63
            if type(entry) != types.StringType:
80
            if not isinstance(entry, basestring):
1531
64
                raise ValueError, 'The entries in "data_files" must be strings'
81
                raise ValueError('The entries in "data_files" must be strings')
1532
65
            
82
            
1533
66
            entry = string.join(string.split(entry, '/'), os.sep)
83
            entry = string.join(string.split(entry, '/'), os.sep)
1534
67
            # entry is a filename or glob pattern
84
            # entry is a filename or glob pattern
1535
@@ -117,25 +134,39 @@
1536
117
    """
134
    """
1537
118
    # Build parameter dictionary
135
    # Build parameter dictionary
1538
119
    kws = {}
136
    kws = {}
1539
137
    newkws = {}
1540
120
    for configuration in configurations:
138
    for configuration in configurations:
1541
121
        kws.update(vars(configuration))
139
        kws.update(vars(configuration))
1542
122
    for name, value in kws.items():
140
    for name, value in kws.items():
1551
123
        if name[:1] == '_' or \
141
        if name[:1] == '_':
1552
124
           type(value) not in (types.StringType,
142
            continue
1553
125
                               types.ListType,
143
        if not isinstance(value, (basestring, list, tuple, dict, int)):
1554
126
                               types.TupleType,
144
            continue
1555
127
                               types.DictType,
145
        newkws[name] = value
1556
128
                               types.IntType,
146
    kws = newkws
1549
129
                               ):
1550
130
            del kws[name]
1557
131
147
1558
132
    # Add setup extensions
148
    # Add setup extensions
1559
133
    cmdclasses = {
149
    cmdclasses = {
1560
150
        'build_ext': mod_build_ext,
1561
134
        'install_data': mod_install_data,
151
        'install_data': mod_install_data,
1562
135
        }
152
        }
1563
136
153
1564
137
    kws['cmdclass'] = cmdclasses
154
    kws['cmdclass'] = cmdclasses
1565
138
155
1566
139
    # Invoke distutils setup
156
    # Invoke distutils setup
1568
140
    apply(setup, (), kws)
157
    try:
1569
158
        setup(**kws)
1570
159
    except BuildFailed, x:
1571
160
        print("One or more C extensions failed to build.")
1572
161
        print("Details: %s" % x)
1573
162
        if os.environ.get('CHEETAH_C_EXTENSIONS_REQUIRED'):
1574
163
            raise x
1575
164
        print("Retrying without C extensions enabled.")
1576
165
1577
166
        del kws['ext_modules']
1578
167
        setup(**kws)
1579
168
1580
169
        print("One or more C extensions failed to build.")
1581
170
        print("Performance enhancements will not be available.")
1582
171
        print("Pure Python installation succeeded.")
1583
141
172
1584
142
173
1585
=== modified file 'TODO'
1586
--- TODO	2007-07-11 14:45:50 +0000
1587
+++ TODO	2010-10-19 20:12:51 +0000
1588
@@ -1,16 +1,9 @@
1602
1
Cheetah TODO list
1
NOTE: Please see http://bugs.cheetahtemplate.org
1603
2
-----------------
2
	for future feature requests/bugs/TODO
1604
3
* If you are working on a task please put your initials at the end of the
3
1605
4
  description
4
1606
5
* When a task is completed please remember to note it in the CHANGES file
5
===============================================================================
1607
6
* Unresolved bugs are listed in the BUGS file.  Resolved bugs are be listed
6
===============================================================================
1595
7
  in the CHANGES file if the bug is considered significant enough and it
1596
8
  affected a released version of Cheetah.
1597
9
1598
10
Required for Cheetah 2.0
1599
11
========================
1600
12
- Replace Optik with Python's optparse.  Optik license has been removed from
1601
13
  Users' Guide.
1608
14
7
1609
15
Desired for Cheetah 2.0
8
Desired for Cheetah 2.0
1610
16
=======================
9
=======================
1611
@@ -38,7 +31,6 @@
1612
38
  leak from one fill to the next.
31
  leak from one fill to the next.
1613
39
32
1614
40
- CheetahWrapper stuff: (MO)
33
- CheetahWrapper stuff: (MO)
1615
41
  * "cheetah compile --shbang '#!/usr/bin/python2.2'"
1616
42
  * "cheetah preview [options] [FILES]"  print template-specific portion of main
34
  * "cheetah preview [options] [FILES]"  print template-specific portion of main
1617
43
    method(s) to stdout, with line numbers based on the .py template module.  
35
    method(s) to stdout, with line numbers based on the .py template module.  
1618
44
    Make a Template method to do the same thing, a la .generatedModuleCode().
36
    Make a Template method to do the same thing, a la .generatedModuleCode().
1619
45
37
1620
=== modified file 'bin/cheetah'
1621
--- bin/cheetah	2004-03-30 18:47:41 +0000
1622
+++ bin/cheetah	2010-10-19 20:12:51 +0000
1623
@@ -1,3 +1,3 @@
1624
1
#!/usr/bin/env python
1
#!/usr/bin/env python
1627
2
from Cheetah.CheetahWrapper import CheetahWrapper
2
from Cheetah.CheetahWrapper import _cheetah
1628
3
CheetahWrapper().main()
3
_cheetah()
1629
4
4
1630
=== added file 'bin/cheetah-analyze'
1631
--- bin/cheetah-analyze	1970-01-01 00:00:00 +0000
1632
+++ bin/cheetah-analyze	2010-10-19 20:12:51 +0000
1633
@@ -0,0 +1,6 @@
1634
1
#!/usr/bin/env python
1635
2
1636
3
from Cheetah import DirectiveAnalyzer
1637
4
1638
5
if __name__ == '__main__':
1639
6
    DirectiveAnalyzer.main()
1640
0
7
1641
=== modified file 'bin/cheetah-compile'
1642
--- bin/cheetah-compile	2004-03-30 18:47:41 +0000
1643
+++ bin/cheetah-compile	2010-10-19 20:12:51 +0000
1644
@@ -1,5 +1,3 @@
1645
1
#!/usr/bin/env python
1
#!/usr/bin/env python
1650
2
import sys
2
from Cheetah.CheetahWrapper import _cheetah_compile
1651
3
from Cheetah.CheetahWrapper import CheetahWrapper
3
_cheetah_compile()
1648
4
sys.argv.insert(1, "compile")
1649
5
CheetahWrapper().main()
1652
6
4
1653
=== removed file 'cachedCompile.py'
1654
--- cachedCompile.py	2006-07-26 22:03:15 +0000
1655
+++ cachedCompile.py	1970-01-01 00:00:00 +0000
1656
@@ -1,11 +0,0 @@
1657
1
from Cheetah.Template import Template
1658
2
source = file('/home/tavis/cvs_working/Cheetah/src/Templates/SkeletonPage.tmpl').read()
1659
3
##klass = Template.compile(source,
1660
4
##                         cacheCompilationResults=1,
1661
5
##                         useCache=1,
1662
6
##                             )
1663
7
for i in range(2000):
1664
8
    klass = Template.compile(source,
1665
9
                             cacheCompilationResults=0,
1666
10
                             useCache=0,
1667
11
                             )
1668
12
0
1669
=== added directory 'cheetah'
1670
=== removed file 'cheetah-mem.py'
1671
--- cheetah-mem.py	2006-07-26 22:03:15 +0000
1672
+++ cheetah-mem.py	1970-01-01 00:00:00 +0000
1673
@@ -1,22 +0,0 @@
1674
1
from Cheetah.Template import Template
1675
2
import gc
1676
3
1677
4
src = open('/tmp/z.py').read()
1678
5
tclass = Template.compile(src)
1679
6
#t = Template(src)
1680
7
nr = 0
1681
8
while True:
1682
9
    #tclass = Template.compile(src)
1683
10
    #t = tclass()
1684
11
    t = Template(src)
1685
12
    
1686
13
    output = t.respond()
1687
14
    
1688
15
    nr += 1
1689
16
    if not nr % 10000:
1690
17
        print 
1691
18
        #print 'collect'
1692
19
	#gc.collect()
1693
20
1694
21
        print 'tclass id', id(t.__class__)
1695
22
        print 'cache size', len(Template._CHEETAH_compileCache.keys())
1696
23
0
1697
=== added file 'cheetah/CacheRegion.py'
1698
--- cheetah/CacheRegion.py	1970-01-01 00:00:00 +0000
1699
+++ cheetah/CacheRegion.py	2010-10-19 20:12:51 +0000
1700
@@ -0,0 +1,136 @@
1701
1
# $Id: CacheRegion.py,v 1.3 2006/01/28 04:19:30 tavis_rudd Exp $
1702
2
'''
1703
3
Cache holder classes for Cheetah:
1704
4
1705
5
Cache regions are defined using the #cache Cheetah directive. Each
1706
6
cache region can be viewed as a dictionary (keyed by cacheRegionID)
1707
7
handling at least one cache item (the default one). It's possible to add
1708
8
cacheItems in a region by using the `varyBy` #cache directive parameter as
1709
9
in the following example::
1710
10
   #def getArticle
1711
11
      this is the article content.
1712
12
   #end def
1713
13
1714
14
   #cache varyBy=$getArticleID()
1715
15
      $getArticle($getArticleID())
1716
16
   #end cache
1717
17
1718
18
The code above will generate a CacheRegion and add new cacheItem for each value
1719
19
of $getArticleID().
1720
20
'''
1721
21
1722
22
try:
1723
23
    from hashlib import md5
1724
24
except ImportError:
1725
25
    from md5 import md5
1726
26
1727
27
import time
1728
28
import Cheetah.CacheStore
1729
29
1730
30
class CacheItem(object):
1731
31
    '''
1732
32
    A CacheItem is a container storing:
1733
33
1734
34
        - cacheID (string)
1735
35
        - refreshTime (timestamp or None) : last time the cache was refreshed
1736
36
        - data (string) : the content of the cache
1737
37
    '''
1738
38
    
1739
39
    def __init__(self, cacheItemID, cacheStore):
1740
40
        self._cacheItemID = cacheItemID
1741
41
        self._cacheStore = cacheStore
1742
42
        self._refreshTime = None
1743
43
        self._expiryTime = 0
1744
44
1745
45
    def hasExpired(self):
1746
46
        return (self._expiryTime and time.time() > self._expiryTime)
1747
47
    
1748
48
    def setExpiryTime(self, time):
1749
49
        self._expiryTime = time
1750
50
1751
51
    def getExpiryTime(self):
1752
52
        return self._expiryTime
1753
53
1754
54
    def setData(self, data):
1755
55
        self._refreshTime = time.time()
1756
56
        self._cacheStore.set(self._cacheItemID, data, self._expiryTime)
1757
57
1758
58
    def getRefreshTime(self):
1759
59
        return self._refreshTime
1760
60
1761
61
    def getData(self):
1762
62
        assert self._refreshTime
1763
63
        return self._cacheStore.get(self._cacheItemID)
1764
64
1765
65
    def renderOutput(self):
1766
66
        """Can be overridden to implement edge-caching"""
1767
67
        return self.getData() or ""
1768
68
1769
69
    def clear(self):
1770
70
        self._cacheStore.delete(self._cacheItemID)
1771
71
        self._refreshTime = None
1772
72
1773
73
class _CacheDataStoreWrapper(object):
1774
74
    def __init__(self, dataStore, keyPrefix):
1775
75
        self._dataStore = dataStore
1776
76
        self._keyPrefix = keyPrefix
1777
77
        
1778
78
    def get(self, key):
1779
79
        return self._dataStore.get(self._keyPrefix+key)
1780
80
1781
81
    def delete(self, key):
1782
82
        self._dataStore.delete(self._keyPrefix+key)
1783
83
1784
84
    def set(self, key, val, time=0):        
1785
85
        self._dataStore.set(self._keyPrefix+key, val, time=time)
1786
86
1787
87
class CacheRegion(object):
1788
88
    '''
1789
89
    A `CacheRegion` stores some `CacheItem` instances.
1790
90
1791
91
    This implementation stores the data in the memory of the current process.
1792
92
    If you need a more advanced data store, create a cacheStore class that works
1793
93
    with Cheetah's CacheStore protocol and provide it as the cacheStore argument
1794
94
    to __init__.  For example you could use
1795
95
    Cheetah.CacheStore.MemcachedCacheStore, a wrapper around the Python
1796
96
    memcached API (http://www.danga.com/memcached).
1797
97
    '''
1798
98
    _cacheItemClass = CacheItem
1799
99
    
1800
100
    def __init__(self, regionID, templateCacheIdPrefix='', cacheStore=None):
1801
101
        self._isNew = True
1802
102
        self._regionID = regionID
1803
103
        self._templateCacheIdPrefix = templateCacheIdPrefix
1804
104
        if not cacheStore:
1805
105
            cacheStore = Cheetah.CacheStore.MemoryCacheStore()
1806
106
        self._cacheStore = cacheStore
1807
107
        self._wrappedCacheDataStore = _CacheDataStoreWrapper(
1808
108
            cacheStore, keyPrefix=templateCacheIdPrefix+':'+regionID+':')
1809
109
        self._cacheItems = {}
1810
110
1811
111
    def isNew(self):
1812
112
        return self._isNew
1813
113
        
1814
114
    def clear(self):
1815
115
        " drop all the caches stored in this cache region "
1816
116
        for cacheItemId in self._cacheItems.keys():
1817
117
            cacheItem = self._cacheItems[cacheItemId]
1818
118
            cacheItem.clear()
1819
119
            del self._cacheItems[cacheItemId]
1820
120
        
1821
121
    def getCacheItem(self, cacheItemID):
1822
122
        """ Lazy access to a cacheItem
1823
123
1824
124
            Try to find a cache in the stored caches. If it doesn't
1825
125
            exist, it's created.
1826
126
            
1827
127
            Returns a `CacheItem` instance.
1828
128
        """
1829
129
        cacheItemID = md5(str(cacheItemID)).hexdigest()
1830
130
        
1831
131
        if cacheItemID not in self._cacheItems:
1832
132
            cacheItem = self._cacheItemClass(
1833
133
                cacheItemID=cacheItemID, cacheStore=self._wrappedCacheDataStore)
1834
134
            self._cacheItems[cacheItemID] = cacheItem
1835
135
            self._isNew = False
1836
136
        return self._cacheItems[cacheItemID]
1837
0
137
1838
=== added file 'cheetah/CacheStore.py'
1839
--- cheetah/CacheStore.py	1970-01-01 00:00:00 +0000
1840
+++ cheetah/CacheStore.py	2010-10-19 20:12:51 +0000
1841
@@ -0,0 +1,106 @@
1842
1
'''
1843
2
Provides several CacheStore backends for Cheetah's caching framework.  The
1844
3
methods provided by these classes have the same semantics as those in the
1845
4
python-memcached API, except for their return values:
1846
5
1847
6
set(key, val, time=0)
1848
7
  set the value unconditionally
1849
8
add(key, val, time=0)
1850
9
  set only if the server doesn't already have this key
1851
10
replace(key, val, time=0)
1852
11
  set only if the server already have this key
1853
12
get(key, val)
1854
13
  returns val or raises a KeyError
1855
14
delete(key)
1856
15
  deletes or raises a KeyError
1857
16
'''
1858
17
import time
1859
18
1860
19
class Error(Exception):
1861
20
    pass
1862
21
1863
22
class AbstractCacheStore(object):
1864
23
1865
24
    def set(self, key, val, time=None):
1866
25
        raise NotImplementedError
1867
26
1868
27
    def add(self, key, val, time=None):
1869
28
        raise NotImplementedError
1870
29
1871
30
    def replace(self, key, val, time=None):
1872
31
        raise NotImplementedError
1873
32
1874
33
    def delete(self, key):
1875
34
        raise NotImplementedError
1876
35
1877
36
    def get(self, key):
1878
37
        raise NotImplementedError
1879
38
1880
39
class MemoryCacheStore(AbstractCacheStore):
1881
40
    def __init__(self):
1882
41
        self._data = {}
1883
42
1884
43
    def set(self, key, val, time=0):
1885
44
        self._data[key] = (val, time)
1886
45
1887
46
    def add(self, key, val, time=0):
1888
47
        if key in self._data:
1889
48
            raise Error('a value for key %r is already in the cache'%key)
1890
49
        self._data[key] = (val, time)
1891
50
1892
51
    def replace(self, key, val, time=0):
1893
52
        if key in self._data:
1894
53
            raise Error('a value for key %r is already in the cache'%key)
1895
54
        self._data[key] = (val, time)
1896
55
1897
56
    def delete(self, key):
1898
57
        del self._data[key]
1899
58
        
1900
59
    def get(self, key):
1901
60
        (val, exptime) = self._data[key]
1902
61
        if exptime and time.time() > exptime:
1903
62
            del self._data[key]
1904
63
            raise KeyError(key)
1905
64
        else:
1906
65
            return val
1907
66
1908
67
    def clear(self):
1909
68
        self._data.clear()        
1910
69
                  
1911
70
class MemcachedCacheStore(AbstractCacheStore):
1912
71
    servers = ('127.0.0.1:11211')
1913
72
    def __init__(self, servers=None, debug=False):
1914
73
        if servers is None:
1915
74
            servers = self.servers
1916
75
        from memcache import Client as MemcachedClient
1917
76
        self._client = MemcachedClient(servers, debug)
1918
77
1919
78
    def set(self, key, val, time=0):
1920
79
        self._client.set(key, val, time)
1921
80
1922
81
    def add(self, key, val, time=0):
1923
82
        res = self._client.add(key, val, time)        
1924
83
        if not res:
1925
84
            raise Error('a value for key %r is already in the cache'%key)
1926
85
        self._data[key] = (val, time)
1927
86
1928
87
    def replace(self, key, val, time=0):
1929
88
        res = self._client.replace(key, val, time)        
1930
89
        if not res:
1931
90
            raise Error('a value for key %r is already in the cache'%key)
1932
91
        self._data[key] = (val, time)
1933
92
1934
93
    def delete(self, key):
1935
94
        res = self._client.delete(key, time=0)        
1936
95
        if not res:
1937
96
            raise KeyError(key)
1938
97
        
1939
98
    def get(self, key):
1940
99
        val = self._client.get(key)
1941
100
        if val is None:
1942
101
            raise KeyError(key)
1943
102
        else:
1944
103
            return val
1945
104
1946
105
    def clear(self):
1947
106
        self._client.flush_all()        
1948
0
107
1949
=== added file 'cheetah/CheetahWrapper.py'
1950
--- cheetah/CheetahWrapper.py	1970-01-01 00:00:00 +0000
1951
+++ cheetah/CheetahWrapper.py	2010-10-19 20:12:51 +0000
1952
@@ -0,0 +1,632 @@
1953
1
# $Id: CheetahWrapper.py,v 1.26 2007/10/02 01:22:04 tavis_rudd Exp $
1954
2
"""Cheetah command-line interface.
1955
3
1956
4
2002-09-03 MSO: Total rewrite.
1957
5
2002-09-04 MSO: Bugfix, compile command was using wrong output ext.
1958
6
2002-11-08 MSO: Another rewrite.
1959
7
1960
8
Meta-Data
1961
9
================================================================================
1962
10
Author: Tavis Rudd <tavis@damnsimple.com> and Mike Orr <sluggoster@gmail.com>>
1963
11
Version: $Revision: 1.26 $
1964
12
Start Date: 2001/03/30
1965
13
Last Revision Date: $Date: 2007/10/02 01:22:04 $
1966
14
"""
1967
15
__author__ = "Tavis Rudd <tavis@damnsimple.com> and Mike Orr <sluggoster@gmail.com>"
1968
16
__revision__ = "$Revision: 1.26 $"[11:-2]
1969
17
1970
18
import getopt, glob, os, pprint, re, shutil, sys
1971
19
import cPickle as pickle
1972
20
from optparse import OptionParser
1973
21
1974
22
from Cheetah.Version import Version
1975
23
from Cheetah.Template import Template, DEFAULT_COMPILER_SETTINGS
1976
24
from Cheetah.Utils.Misc import mkdirsWithPyInitFiles
1977
25
1978
26
optionDashesRE = re.compile(  R"^-{1,2}"  )
1979
27
moduleNameRE = re.compile(  R"^[a-zA-Z_][a-zA-Z_0-9]*$"  )
1980
28
   
1981
29
def fprintfMessage(stream, format, *args):
1982
30
    if format[-1:] == '^':
1983
31
        format = format[:-1]
1984
32
    else:
1985
33
        format += '\n'
1986
34
    if args:
1987
35
        message = format % args
1988
36
    else:
1989
37
        message = format
1990
38
    stream.write(message)
1991
39
1992
40
class Error(Exception):
1993
41
    pass
1994
42
1995
43
1996
44
class Bundle:
1997
45
    """Wrap the source, destination and backup paths in one neat little class.
1998
46
       Used by CheetahWrapper.getBundles().
1999
47
    """
2000
48
    def __init__(self, **kw):
2001
49
        self.__dict__.update(kw)
2002
50
2003
51
    def __repr__(self):
2004
52
        return "<Bundle %r>" % self.__dict__
2005
53
2006
54
2007
55
##################################################
2008
56
## USAGE FUNCTION & MESSAGES
2009
57
2010
58
def usage(usageMessage, errorMessage="", out=sys.stderr):
2011
59
    """Write help text, an optional error message, and abort the program.
2012
60
    """
2013
61
    out.write(WRAPPER_TOP)
2014
62
    out.write(usageMessage)
2015
63
    exitStatus = 0
2016
64
    if errorMessage:
2017
65
        out.write('\n')
2018
66
        out.write("*** USAGE ERROR ***: %s\n" % errorMessage)
2019
67
        exitStatus = 1
2020
68
    sys.exit(exitStatus)
2021
69
             
2022
70
2023
71
WRAPPER_TOP = """\
2024
72
         __  ____________  __
2025
73
         \ \/            \/ /
2026
74
          \/    *   *     \/    CHEETAH %(Version)s Command-Line Tool
2027
75
           \      |       / 
2028
76
            \  ==----==  /      by Tavis Rudd <tavis@damnsimple.com>
2029
77
             \__________/       and Mike Orr <sluggoster@gmail.com>
2030
78
              
2031
79
""" % globals()
2032
80
2033
81
2034
82
HELP_PAGE1 = """\
2035
83
USAGE:
2036
84
------
2037
85
  cheetah compile [options] [FILES ...]     : Compile template definitions
2038
86
  cheetah fill [options] [FILES ...]        : Fill template definitions
2039
87
  cheetah help                              : Print this help message
2040
88
  cheetah options                           : Print options help message
2041
89
  cheetah test [options]                    : Run Cheetah's regression tests
2042
90
                                            : (same as for unittest)
2043
91
  cheetah version                           : Print Cheetah version number
2044
92
2045
93
You may abbreviate the command to the first letter; e.g., 'h' == 'help'.
2046
94
If FILES is a single "-", read standard input and write standard output.
2047
95
Run "cheetah options" for the list of valid options.
2048
96
"""
2049
97
2050
98
##################################################
2051
99
## CheetahWrapper CLASS
2052
100
2053
101
class CheetahWrapper(object):
2054
102
    MAKE_BACKUPS = True
2055
103
    BACKUP_SUFFIX = ".bak"
2056
104
    _templateClass = None
2057
105
    _compilerSettings = None    
2058
106
2059
107
    def __init__(self):
2060
108
        self.progName = None
2061
109
        self.command = None
2062
110
        self.opts = None
2063
111
        self.pathArgs = None
2064
112
        self.sourceFiles = []
2065
113
        self.searchList = []
2066
114
        self.parser = None
2067
115
2068
116
    ##################################################
2069
117
    ## MAIN ROUTINE
2070
118
2071
119
    def main(self, argv=None):
2072
120
        """The main program controller."""
2073
121
2074
122
        if argv is None:
2075
123
            argv = sys.argv
2076
124
2077
125
        # Step 1: Determine the command and arguments.
2078
126
        try:
2079
127
            self.progName = progName = os.path.basename(argv[0])
2080
128
            self.command = command = optionDashesRE.sub("", argv[1])
2081
129
            if command == 'test':
2082
130
                self.testOpts = argv[2:]
2083
131
            else:
2084
132
                self.parseOpts(argv[2:])
2085
133
        except IndexError:
2086
134
            usage(HELP_PAGE1, "not enough command-line arguments")
2087
135
2088
136
        # Step 2: Call the command
2089
137
        meths = (self.compile, self.fill, self.help, self.options,
2090
138
            self.test, self.version)
2091
139
        for meth in meths:
2092
140
            methName = meth.__name__
2093
141
            # Or meth.im_func.func_name
2094
142
            # Or meth.func_name (Python >= 2.1 only, sometimes works on 2.0)
2095
143
            methInitial = methName[0]
2096
144
            if command in (methName, methInitial):
2097
145
                sys.argv[0] += (" " + methName)
2098
146
                # @@MO: I don't necessarily agree sys.argv[0] should be 
2099
147
                # modified.
2100
148
                meth()
2101
149
                return
2102
150
        # If none of the commands matched.
2103
151
        usage(HELP_PAGE1, "unknown command '%s'" % command)
2104
152
2105
153
    def parseOpts(self, args):
2106
154
        C, D, W = self.chatter, self.debug, self.warn
2107
155
        self.isCompile = isCompile = self.command[0] == 'c'
2108
156
        defaultOext = isCompile and ".py" or ".html"
2109
157
        self.parser = OptionParser()
2110
158
        pao = self.parser.add_option
2111
159
        pao("--idir", action="store", dest="idir", default='', help='Input directory (defaults to current directory)')
2112
160
        pao("--odir", action="store", dest="odir", default="", help='Output directory (defaults to current directory)')
2113
161
        pao("--iext", action="store", dest="iext", default=".tmpl", help='File input extension (defaults: compile: .tmpl, fill: .tmpl)')
2114
162
        pao("--oext", action="store", dest="oext", default=defaultOext, help='File output extension (defaults: compile: .py, fill: .html)')
2115
163
        pao("-R", action="store_true", dest="recurse", default=False, help='Recurse through subdirectories looking for input files')
2116
164
        pao("--stdout", "-p", action="store_true", dest="stdout", default=False, help='Send output to stdout instead of writing to a file')
2117
165
        pao("--quiet", action="store_false", dest="verbose", default=True, help='Do not print informational messages to stdout')
2118
166
        pao("--debug", action="store_true", dest="debug", default=False, help='Print diagnostic/debug information to stderr')
2119
167
        pao("--env", action="store_true", dest="env", default=False, help='Pass the environment into the search list')
2120
168
        pao("--pickle", action="store", dest="pickle", default="", help='Unpickle FILE and pass it through in the search list')
2121
169
        pao("--flat", action="store_true", dest="flat", default=False, help='Do not build destination subdirectories')
2122
170
        pao("--nobackup", action="store_true", dest="nobackup", default=False, help='Do not make backup files when generating new ones')
2123
171
        pao("--settings", action="store", dest="compilerSettingsString", default=None, help='String of compiler settings to pass through, e.g. --settings="useNameMapper=False,useFilters=False"')
2124
172
        pao('--print-settings', action='store_true', dest='print_settings', help='Print out the list of available compiler settings')
2125
173
        pao("--templateAPIClass", action="store", dest="templateClassName", default=None, help='Name of a subclass of Cheetah.Template.Template to use for compilation, e.g. MyTemplateClass')
2126
174
        pao("--parallel", action="store", type="int", dest="parallel", default=1, help='Compile/fill templates in parallel, e.g. --parallel=4')
2127
175
        pao('--shbang', dest='shbang', default='#!/usr/bin/env python', help='Specify the shbang to place at the top of compiled templates, e.g. --shbang="#!/usr/bin/python2.6"')
2128
176
2129
177
        opts, files = self.parser.parse_args(args)
2130
178
        self.opts = opts
2131
179
        if sys.platform == "win32":
2132
180
            new_files = []
2133
181
            for spec in files:
2134
182
                file_list = glob.glob(spec)
2135
183
                if file_list:
2136
184
                    new_files.extend(file_list)
2137
185
                else:
2138
186
                    new_files.append(spec)
2139
187
            files = new_files
2140
188
        self.pathArgs = files
2141
189
2142
190
        D("""\
2143
191
cheetah compile %s
2144
192
Options are
2145
193
%s
2146
194
Files are %s""", args, pprint.pformat(vars(opts)), files)
2147
195
2148
196
2149
197
        if opts.print_settings:
2150
198
            print() 
2151
199
            print('>> Available Cheetah compiler settings:')
2152
200
            from Cheetah.Compiler import _DEFAULT_COMPILER_SETTINGS
2153
201
            listing = _DEFAULT_COMPILER_SETTINGS
2154
202
            listing.sort(key=lambda l: l[0][0].lower())
2155
203
2156
204
            for l in listing:
2157
205
                print('\t%s (default: "%s")\t%s' % l)
2158
206
            sys.exit(0)
2159
207
2160
208
        #cleanup trailing path separators
2161
209
        seps = [sep for sep in [os.sep, os.altsep] if sep]
2162
210
        for attr in ['idir', 'odir']:
2163
211
            for sep in seps:
2164
212
                path = getattr(opts, attr, None)
2165
213
                if path and path.endswith(sep):
2166
214
                    path = path[:-len(sep)]
2167
215
                    setattr(opts, attr, path)
2168
216
                    break
2169
217
2170
218
        self._fixExts()
2171
219
        if opts.env:
2172
220
            self.searchList.insert(0, os.environ)
2173
221
        if opts.pickle:
2174
222
            f = open(opts.pickle, 'rb')
2175
223
            unpickled = pickle.load(f)
2176
224
            f.close()
2177
225
            self.searchList.insert(0, unpickled)
2178
226
2179
227
    ##################################################
2180
228
    ## COMMAND METHODS
2181
229
2182
230
    def compile(self):
2183
231
        self._compileOrFill()
2184
232
2185
233
    def fill(self):
2186
234
        from Cheetah.ImportHooks import install
2187
235
        install()        
2188
236
        self._compileOrFill()
2189
237
2190
238
    def help(self):
2191
239
        usage(HELP_PAGE1, "", sys.stdout)
2192
240
2193
241
    def options(self):
2194
242
        return self.parser.print_help()
2195
243
2196
244
    def test(self):
2197
245
        # @@MO: Ugly kludge.
2198
246
        TEST_WRITE_FILENAME = 'cheetah_test_file_creation_ability.tmp'
2199
247
        try:
2200
248
            f = open(TEST_WRITE_FILENAME, 'w')
2201
249
        except:
2202
250
            sys.exit("""\
2203
251
Cannot run the tests because you don't have write permission in the current
2204
252
directory.  The tests need to create temporary files.  Change to a directory
2205
253
you do have write permission to and re-run the tests.""")
2206
254
        else:
2207
255
            f.close()
2208
256
            os.remove(TEST_WRITE_FILENAME)
2209
257
        # @@MO: End ugly kludge.
2210
258
        from Cheetah.Tests import Test
2211
259
        import unittest
2212
260
        verbosity = 1
2213
261
        if '-q' in self.testOpts:
2214
262
            verbosity = 0
2215
263
        if '-v' in self.testOpts:
2216
264
            verbosity = 2
2217
265
        runner = unittest.TextTestRunner(verbosity=verbosity)
2218
266
        runner.run(unittest.TestSuite(Test.suites))
2219
267
        
2220
268
    def version(self):
2221
269
        print(Version)
2222
270
2223
271
    # If you add a command, also add it to the 'meths' variable in main().
2224
272
    
2225
273
    ##################################################
2226
274
    ## LOGGING METHODS
2227
275
2228
276
    def chatter(self, format, *args):
2229
277
        """Print a verbose message to stdout.  But don't if .opts.stdout is
2230
278
           true or .opts.verbose is false.
2231
279
        """
2232
280
        if self.opts.stdout or not self.opts.verbose:
2233
281
            return
2234
282
        fprintfMessage(sys.stdout, format, *args)
2235
283
2236
284
2237
285
    def debug(self, format, *args):
2238
286
        """Print a debugging message to stderr, but don't if .debug is
2239
287
           false.
2240
288
        """
2241
289
        if self.opts.debug:
2242
290
            fprintfMessage(sys.stderr, format, *args)
2243
291
    
2244
292
    def warn(self, format, *args):
2245
293
        """Always print a warning message to stderr.
2246
294
        """
2247
295
        fprintfMessage(sys.stderr, format, *args)
2248
296
2249
297
    def error(self, format, *args):
2250
298
        """Always print a warning message to stderr and exit with an error code.        
2251
299
        """
2252
300
        fprintfMessage(sys.stderr, format, *args)
2253
301
        sys.exit(1)
2254
302
2255
303
    ##################################################
2256
304
    ## HELPER METHODS
2257
305
2258
306
2259
307
    def _fixExts(self):
2260
308
        assert self.opts.oext, "oext is empty!"
2261
309
        iext, oext = self.opts.iext, self.opts.oext
2262
310
        if iext and not iext.startswith("."):
2263
311
            self.opts.iext = "." + iext
2264
312
        if oext and not oext.startswith("."):
2265
313
            self.opts.oext = "." + oext
2266
314
    
2267
315
2268
316
2269
317
    def _compileOrFill(self):
2270
318
        C, D, W = self.chatter, self.debug, self.warn
2271
319
        opts, files = self.opts, self.pathArgs
2272
320
        if files == ["-"]: 
2273
321
            self._compileOrFillStdin()
2274
322
            return
2275
323
        elif not files and opts.recurse:
2276
324
            which = opts.idir and "idir" or "current"
2277
325
            C("Drilling down recursively from %s directory.", which)
2278
326
            sourceFiles = []
2279
327
            dir = os.path.join(self.opts.idir, os.curdir)
2280
328
            os.path.walk(dir, self._expandSourceFilesWalk, sourceFiles)
2281
329
        elif not files:
2282
330
            usage(HELP_PAGE1, "Neither files nor -R specified!")
2283
331
        else:
2284
332
            sourceFiles = self._expandSourceFiles(files, opts.recurse, True)
2285
333
        sourceFiles = [os.path.normpath(x) for x in sourceFiles]
2286
334
        D("All source files found: %s", sourceFiles)
2287
335
        bundles = self._getBundles(sourceFiles)
2288
336
        D("All bundles: %s", pprint.pformat(bundles))
2289
337
        if self.opts.flat:
2290
338
            self._checkForCollisions(bundles)
2291
339
2292
340
        # In parallel mode a new process is forked for each template
2293
341
        # compilation, out of a pool of size self.opts.parallel. This is not
2294
342
        # really optimal in all cases (e.g. probably wasteful for small
2295
343
        # templates), but seems to work well in real life for me.
2296
344
        #
2297
345
        # It also won't work for Windows users, but I'm not going to lose any
2298
346
        # sleep over that.
2299
347
        if self.opts.parallel > 1:
2300
348
            bad_child_exit = 0
2301
349
            pid_pool = set()
2302
350
2303
351
            def child_wait():
2304
352
                pid, status = os.wait()
2305
353
                pid_pool.remove(pid)
2306
354
                return os.WEXITSTATUS(status)
2307
355
2308
356
            while bundles:
2309
357
                b = bundles.pop()
2310
358
                pid = os.fork()
2311
359
                if pid:
2312
360
                    pid_pool.add(pid)
2313
361
                else:
2314
362
                    self._compileOrFillBundle(b)
2315
363
                    sys.exit(0)
2316
364
2317
365
                if len(pid_pool) == self.opts.parallel:
2318
366
                    bad_child_exit = child_wait()
2319
367
                    if bad_child_exit:
2320
368
                        break
2321
369
2322
370
            while pid_pool:
2323
371
                child_exit = child_wait()
2324
372
                if not bad_child_exit:
2325
373
                    bad_child_exit = child_exit
2326
374
2327
375
            if bad_child_exit:
2328
376
                sys.exit("Child process failed, exited with code %d" % bad_child_exit)
2329
377
2330
378
        else:
2331
379
            for b in bundles:
2332
380
                self._compileOrFillBundle(b)
2333
381
2334
382
    def _checkForCollisions(self, bundles):
2335
383
        """Check for multiple source paths writing to the same destination
2336
384
           path.
2337
385
        """
2338
386
        C, D, W = self.chatter, self.debug, self.warn
2339
387
        isError = False
2340
388
        dstSources = {}
2341
389
        for b in bundles:
2342
390
            if b.dst in dstSources:
2343
391
                dstSources[b.dst].append(b.src)
2344
392
            else:
2345
393
                dstSources[b.dst] = [b.src]
2346
394
        keys = sorted(dstSources.keys())
2347
395
        for dst in keys:
2348
396
            sources = dstSources[dst]
2349
397
            if len(sources) > 1:
2350
398
                isError = True
2351
399
                sources.sort()
2352
400
                fmt = "Collision: multiple source files %s map to one destination file %s"
2353
401
                W(fmt, sources, dst)
2354
402
        if isError:
2355
403
            what = self.isCompile and "Compilation" or "Filling"
2356
404
            sys.exit("%s aborted due to collisions" % what)
2357
405
                
2358
406
2359
407
    def _expandSourceFilesWalk(self, arg, dir, files):
2360
408
        """Recursion extension for .expandSourceFiles().
2361
409
           This method is a callback for os.path.walk().
2362
410
           'arg' is a list to which successful paths will be appended.
2363
411
        """
2364
412
        iext = self.opts.iext
2365
413
        for f in files:
2366
414
            path = os.path.join(dir, f)
2367
415
            if   path.endswith(iext) and os.path.isfile(path):
2368
416
                arg.append(path)
2369
417
            elif os.path.islink(path) and os.path.isdir(path):
2370
418
                os.path.walk(path, self._expandSourceFilesWalk, arg)
2371
419
            # If is directory, do nothing; 'walk' will eventually get it.
2372
420
2373
421
2374
422
    def _expandSourceFiles(self, files, recurse, addIextIfMissing):
2375
423
        """Calculate source paths from 'files' by applying the 
2376
424
           command-line options.
2377
425
        """
2378
426
        C, D, W = self.chatter, self.debug, self.warn
2379
427
        idir = self.opts.idir
2380
428
        iext = self.opts.iext
2381
429
        files = [] 
2382
430
        for f in self.pathArgs:
2383
431
            oldFilesLen = len(files)
2384
432
            D("Expanding %s", f)
2385
433
            path = os.path.join(idir, f)
2386
434
            pathWithExt = path + iext # May or may not be valid.
2387
435
            if os.path.isdir(path):
2388
436
                if recurse:
2389
437
                    os.path.walk(path, self._expandSourceFilesWalk, files)
2390
438
                else:
2391
439
                    raise Error("source file '%s' is a directory" % path)
2392
440
            elif os.path.isfile(path):
2393
441
                files.append(path)
2394
442
            elif (addIextIfMissing and not path.endswith(iext) and 
2395
443
                  os.path.isfile(pathWithExt)):
2396
444
                files.append(pathWithExt)
2397
445
                # Do not recurse directories discovered by iext appending.
2398
446
            elif os.path.exists(path):
2399
447
                W("Skipping source file '%s', not a plain file.", path)
2400
448
            else:
2401
449
                W("Skipping source file '%s', not found.", path)
2402
450
            if len(files) > oldFilesLen:
2403
451
                D("  ... found %s", files[oldFilesLen:])
2404
452
        return files
2405
453
2406
454
2407
455
    def _getBundles(self, sourceFiles):
2408
456
        flat = self.opts.flat
2409
457
        idir = self.opts.idir
2410
458
        iext = self.opts.iext
2411
459
        nobackup = self.opts.nobackup
2412
460
        odir = self.opts.odir
2413
461
        oext = self.opts.oext
2414
462
        idirSlash = idir + os.sep
2415
463
        bundles = []
2416
464
        for src in sourceFiles:
2417
465
            # 'base' is the subdirectory plus basename.
2418
466
            base = src
2419
467
            if idir and src.startswith(idirSlash):
2420
468
                base = src[len(idirSlash):]
2421
469
            if iext and base.endswith(iext):
2422
470
                base = base[:-len(iext)]
2423
471
            basename = os.path.basename(base)
2424
472
            if flat:
2425
473
                dst = os.path.join(odir, basename + oext)
2426
474
            else:
2427
475
                dbn = basename
2428
476
                if odir and base.startswith(os.sep):
2429
477
                    odd = odir
2430
478
                    while odd != '':
2431
479
                        idx = base.find(odd)
2432
480
                        if idx == 0:
2433
481
                            dbn = base[len(odd):]
2434
482
                            if dbn[0] == '/':
2435
483
                                dbn = dbn[1:]
2436
484
                            break
2437
485
                        odd = os.path.dirname(odd)
2438
486
                        if odd == '/':
2439
487
                            break
2440
488
                    dst = os.path.join(odir, dbn + oext)
2441
489
                else:
2442
490
                    dst = os.path.join(odir, base + oext)
2443
491
            bak = dst + self.BACKUP_SUFFIX
2444
492
            b = Bundle(src=src, dst=dst, bak=bak, base=base, basename=basename)
2445
493
            bundles.append(b)
2446
494
        return bundles
2447
495
2448
496
2449
497
    def _getTemplateClass(self):
2450
498
        C, D, W = self.chatter, self.debug, self.warn
2451
499
        modname = None
2452
500
        if self._templateClass:
2453
501
            return self._templateClass
2454
502
2455
503
        modname = self.opts.templateClassName
2456
504
2457
505
        if not modname:
2458
506
            return Template
2459
507
        p = modname.rfind('.')
2460
508
        if ':' not in modname:
2461
509
            self.error('The value of option --templateAPIClass is invalid\n'
2462
510
                       'It must be in the form "module:class", '
2463
511
                       'e.g. "Cheetah.Template:Template"')
2464
512
            
2465
513
        modname, classname = modname.split(':')
2466
514
2467
515
        C('using --templateAPIClass=%s:%s'%(modname, classname))
2468
516
        
2469
517
        if p >= 0:
2470
518
            mod = getattr(__import__(modname[:p], {}, {}, [modname[p+1:]]), modname[p+1:])
2471
519
        else:
2472
520
            mod = __import__(modname, {}, {}, [])
2473
521
2474
522
        klass = getattr(mod, classname, None)
2475
523
        if klass:
2476
524
            self._templateClass = klass
2477
525
            return klass
2478
526
        else:
2479
527
            self.error('**Template class specified in option --templateAPIClass not found\n'
2480
528
                       '**Falling back on Cheetah.Template:Template')
2481
529
2482
530
2483
531
    def _getCompilerSettings(self):
2484
532
        if self._compilerSettings:
2485
533
            return self._compilerSettings
2486
534
2487
535
        def getkws(**kws):
2488
536
            return kws
2489
537
        if self.opts.compilerSettingsString:
2490
538
            try:
2491
539
                exec('settings = getkws(%s)'%self.opts.compilerSettingsString)
2492
540
            except:                
2493
541
                self.error("There's an error in your --settings option."
2494
542
                          "It must be valid Python syntax.\n"
2495
543
                          +"    --settings='%s'\n"%self.opts.compilerSettingsString
2496
544
                          +"  %s: %s"%sys.exc_info()[:2] 
2497
545
                          )
2498
546
2499
547
            validKeys = DEFAULT_COMPILER_SETTINGS.keys()
2500
548
            if [k for k in settings.keys() if k not in validKeys]:
2501
549
                self.error(
2502
550
                    'The --setting "%s" is not a valid compiler setting name.'%k)
2503
551
            
2504
552
            self._compilerSettings = settings
2505
553
            return settings
2506
554
        else:
2507
555
            return {}
2508
556
2509
557
    def _compileOrFillStdin(self):
2510
558
        TemplateClass = self._getTemplateClass()
2511
559
        compilerSettings = self._getCompilerSettings()
2512
560
        if self.isCompile:
2513
561
            pysrc = TemplateClass.compile(file=sys.stdin,
2514
562
                                          compilerSettings=compilerSettings,
2515
563
                                          returnAClass=False)
2516
564
            output = pysrc
2517
565
        else:
2518
566
            output = str(TemplateClass(file=sys.stdin, compilerSettings=compilerSettings))
2519
567
        sys.stdout.write(output)
2520
568
2521
569
    def _compileOrFillBundle(self, b):
2522
570
        C, D, W = self.chatter, self.debug, self.warn
2523
571
        TemplateClass = self._getTemplateClass()
2524
572
        compilerSettings = self._getCompilerSettings()
2525
573
        src = b.src
2526
574
        dst = b.dst
2527
575
        base = b.base
2528
576
        basename = b.basename
2529
577
        dstDir = os.path.dirname(dst)
2530
578
        what = self.isCompile and "Compiling" or "Filling"
2531
579
        C("%s %s -> %s^", what, src, dst) # No trailing newline.
2532
580
        if os.path.exists(dst) and not self.opts.nobackup:
2533
581
            bak = b.bak
2534
582
            C(" (backup %s)", bak) # On same line as previous message.
2535
583
        else:
2536
584
            bak = None
2537
585
            C("")
2538
586
        if self.isCompile:
2539
587
            if not moduleNameRE.match(basename):
2540
588
                tup = basename, src
2541
589
                raise Error("""\
2542
590
%s: base name %s contains invalid characters.  It must
2543
591
be named according to the same rules as Python modules.""" % tup)
2544
592
            pysrc = TemplateClass.compile(file=src, returnAClass=False,
2545
593
                                          moduleName=basename,
2546
594
                                          className=basename,
2547
595
                                          commandlineopts=self.opts,
2548
596
                                          compilerSettings=compilerSettings)
2549
597
            output = pysrc
2550
598
        else:
2551
599
            #output = str(TemplateClass(file=src, searchList=self.searchList))
2552
600
            tclass = TemplateClass.compile(file=src, compilerSettings=compilerSettings)
2553
601
            output = str(tclass(searchList=self.searchList))
2554
602
            
2555
603
        if bak:
2556
604
            shutil.copyfile(dst, bak)
2557
605
        if dstDir and not os.path.exists(dstDir):
2558
606
            if self.isCompile:
2559
607
                mkdirsWithPyInitFiles(dstDir)
2560
608
            else:
2561
609
                os.makedirs(dstDir)
2562
610
        if self.opts.stdout:
2563
611
            sys.stdout.write(output)
2564
612
        else:
2565
613
            f = open(dst, 'w')
2566
614
            f.write(output)
2567
615
            f.close()
2568
616
            
2569
617
2570
618
# Called when invoked as `cheetah`
2571
619
def _cheetah():
2572
620
    CheetahWrapper().main()
2573
621
2574
622
# Called when invoked as `cheetah-compile`
2575
623
def _cheetah_compile():
2576
624
    sys.argv.insert(1, "compile")
2577
625
    CheetahWrapper().main()
2578
626
2579
627
2580
628
##################################################
2581
629
## if run from the command line
2582
630
if __name__ == '__main__':  CheetahWrapper().main()
2583
631
2584
632
# vim: shiftwidth=4 tabstop=4 expandtab
2585
0
633
2586
=== added file 'cheetah/Compiler.py'
2587
--- cheetah/Compiler.py	1970-01-01 00:00:00 +0000
2588
+++ cheetah/Compiler.py	2010-10-19 20:12:51 +0000
2589
@@ -0,0 +1,2002 @@
2590
1
'''
2591
2
    Compiler classes for Cheetah:
2592
3
    ModuleCompiler aka 'Compiler'
2593
4
    ClassCompiler
2594
5
    MethodCompiler
2595
6
2596
7
    If you are trying to grok this code start with ModuleCompiler.__init__,
2597
8
    ModuleCompiler.compile, and ModuleCompiler.__getattr__.
2598
9
'''
2599
10
2600
11
import sys
2601
12
import os
2602
13
import os.path
2603
14
from os.path import getmtime, exists
2604
15
import re
2605
16
import types
2606
17
import time
2607
18
import random
2608
19
import warnings
2609
20
import copy
2610
21
2611
22
from Cheetah.Version import Version, VersionTuple
2612
23
from Cheetah.SettingsManager import SettingsManager
2613
24
from Cheetah.Utils.Indenter import indentize # an undocumented preprocessor
2614
25
from Cheetah import ErrorCatchers
2615
26
from Cheetah import NameMapper
2616
27
from Cheetah.Parser import Parser, ParseError, specialVarRE, \
2617
28
     STATIC_CACHE, REFRESH_CACHE, SET_LOCAL, SET_GLOBAL, SET_MODULE, \
2618
29
     unicodeDirectiveRE, encodingDirectiveRE, escapedNewlineRE
2619
30
2620
31
from Cheetah.NameMapper import NotFound, valueForName, valueFromSearchList, valueFromFrameOrSearchList
2621
32
VFFSL=valueFromFrameOrSearchList
2622
33
VFSL=valueFromSearchList
2623
34
VFN=valueForName
2624
35
currentTime=time.time
2625
36
2626
37
class Error(Exception): pass
2627
38
2628
39
# Settings format: (key, default, docstring)
2629
40
_DEFAULT_COMPILER_SETTINGS = [
2630
41
    ('useNameMapper', True, 'Enable NameMapper for dotted notation and searchList support'),
2631
42
    ('useSearchList', True, 'Enable the searchList, requires useNameMapper=True, if disabled, first portion of the $variable is a global, builtin, or local variable that doesn\'t need looking up in the searchList'),
2632
43
    ('allowSearchListAsMethArg', True, ''),
2633
44
    ('useAutocalling', True, 'Detect and call callable objects in searchList, requires useNameMapper=True'),
2634
45
    ('useStackFrames', True, 'Used for NameMapper.valueFromFrameOrSearchList rather than NameMapper.valueFromSearchList'),
2635
46
    ('useErrorCatcher', False, 'Turn on the #errorCatcher directive for catching NameMapper errors, etc'),
2636
47
    ('alwaysFilterNone', True, 'Filter out None prior to calling the #filter'),
2637
48
    ('useFilters', True, 'If False, pass output through str()'),
2638
49
    ('includeRawExprInFilterArgs', True, ''),
2639
50
    ('useLegacyImportMode', True, 'All #import statements are relocated to the top of the generated Python module'),
2640
51
    ('prioritizeSearchListOverSelf', False, 'When iterating the searchList, look into the searchList passed into the initializer instead of Template members first'),
2641
52
2642
53
    ('autoAssignDummyTransactionToSelf', False, ''),
2643
54
    ('useKWsDictArgForPassingTrans', True, ''),
2644
55
2645
56
    ('commentOffset', 1, ''),
2646
57
    ('outputRowColComments', True, ''),
2647
58
    ('includeBlockMarkers', False, 'Wrap #block\'s in a comment in the template\'s output'),
2648
59
    ('blockMarkerStart', ('\n<!-- START BLOCK: ', ' -->\n'), ''),
2649
60
    ('blockMarkerEnd', ('\n<!-- END BLOCK: ', ' -->\n'), ''),
2650
61
    ('defDocStrMsg', 'Autogenerated by Cheetah: The Python-Powered Template Engine', ''),
2651
62
    ('setup__str__method', False, ''),
2652
63
    ('mainMethodName', 'respond', ''),
2653
64
    ('mainMethodNameForSubclasses', 'writeBody', ''),
2654
65
    ('indentationStep', ' ' * 4, ''),
2655
66
    ('initialMethIndentLevel', 2, ''),
2656
67
    ('monitorSrcFile', False, ''),
2657
68
    ('outputMethodsBeforeAttributes', True, ''),
2658
69
    ('addTimestampsToCompilerOutput', True, ''),
2659
70
2660
71
    ## Customizing the #extends directive
2661
72
    ('autoImportForExtendsDirective', True, ''),
2662
73
    ('handlerForExtendsDirective', None, ''),
2663
74
2664
75
    ('disabledDirectives', [], 'List of directive keys to disable (without starting "#")'),
2665
76
    ('enabledDirectives', [], 'List of directive keys to enable (without starting "#")'),
2666
77
    ('disabledDirectiveHooks', [], 'callable(parser, directiveKey)'),
2667
78
    ('preparseDirectiveHooks', [], 'callable(parser, directiveKey)'),
2668
79
    ('postparseDirectiveHooks', [], 'callable(parser, directiveKey)'),
2669
80
    ('preparsePlaceholderHooks', [], 'callable(parser)'),
2670
81
    ('postparsePlaceholderHooks', [], 'callable(parser)'),
2671
82
    ('expressionFilterHooks', [], '''callable(parser, expr, exprType, rawExpr=None, startPos=None), exprType is the name of the directive, "psp" or "placeholder" The filters *must* return the expr or raise an expression, they can modify the expr if needed'''),
2672
83
    ('templateMetaclass', None, 'Strictly optional, only will work with new-style basecalsses as well'),
2673
84
    ('i18NFunctionName', 'self.i18n', ''),
2674
85
2675
86
    ('cheetahVarStartToken', '$', ''),
2676
87
    ('commentStartToken', '##', ''),
2677
88
    ('multiLineCommentStartToken', '#*', ''),
2678
89
    ('multiLineCommentEndToken', '*#', ''),
2679
90
    ('gobbleWhitespaceAroundMultiLineComments', True, ''),
2680
91
    ('directiveStartToken', '#', ''),
2681
92
    ('directiveEndToken', '#', ''),
2682
93
    ('allowWhitespaceAfterDirectiveStartToken', False, ''),
2683
94
    ('PSPStartToken', '<%', ''),
2684
95
    ('PSPEndToken', '%>', ''),
2685
96
    ('EOLSlurpToken', '#', ''),
2686
97
    ('gettextTokens', ["_", "N_", "ngettext"], ''),
2687
98
    ('allowExpressionsInExtendsDirective', False, ''),
2688
99
    ('allowEmptySingleLineMethods', False, ''),
2689
100
    ('allowNestedDefScopes', True, ''),
2690
101
    ('allowPlaceholderFilterArgs', True, ''),
2691
102
]
2692
103
2693
104
DEFAULT_COMPILER_SETTINGS = dict([(v[0], v[1]) for v in _DEFAULT_COMPILER_SETTINGS])
2694
105
2695
106
2696
107
2697
108
class GenUtils(object):
2698
109
    """An abstract baseclass for the Compiler classes that provides methods that
2699
110
    perform generic utility functions or generate pieces of output code from
2700
111
    information passed in by the Parser baseclass.  These methods don't do any
2701
112
    parsing themselves.
2702
113
    """
2703
114
2704
115
    def genTimeInterval(self, timeString):
2705
116
        ##@@ TR: need to add some error handling here
2706
117
        if timeString[-1] == 's':
2707
118
            interval = float(timeString[:-1])
2708
119
        elif timeString[-1] == 'm':
2709
120
            interval = float(timeString[:-1])*60
2710
121
        elif timeString[-1] == 'h':
2711
122
            interval = float(timeString[:-1])*60*60
2712
123
        elif timeString[-1] == 'd':
2713
124
            interval = float(timeString[:-1])*60*60*24
2714
125
        elif timeString[-1] == 'w':
2715
126
            interval = float(timeString[:-1])*60*60*24*7
2716
127
        else:                       # default to minutes
2717
128
            interval = float(timeString)*60
2718
129
        return interval
2719
130
2720
131
    def genCacheInfo(self, cacheTokenParts):
2721
132
        """Decipher a placeholder cachetoken
2722
133
        """
2723
134
        cacheInfo = {}
2724
135
        if cacheTokenParts['REFRESH_CACHE']:
2725
136
            cacheInfo['type'] = REFRESH_CACHE
2726
137
            cacheInfo['interval'] = self.genTimeInterval(cacheTokenParts['interval'])
2727
138
        elif cacheTokenParts['STATIC_CACHE']:
2728
139
            cacheInfo['type'] = STATIC_CACHE
2729
140
        return cacheInfo                # is empty if no cache
2730
141
2731
142
    def genCacheInfoFromArgList(self, argList):
2732
143
        cacheInfo = {'type':REFRESH_CACHE}
2733
144
        for key, val in argList:
2734
145
            if val[0] in '"\'':
2735
146
                val = val[1:-1]
2736
147
2737
148
            if key == 'timer':
2738
149
                key = 'interval'
2739
150
                val = self.genTimeInterval(val)
2740
151
                
2741
152
            cacheInfo[key] = val
2742
153
        return cacheInfo
2743
154
        
2744
155
    def genCheetahVar(self, nameChunks, plain=False):
2745
156
        if nameChunks[0][0] in self.setting('gettextTokens'):
2746
157
            self.addGetTextVar(nameChunks) 
2747
158
        if self.setting('useNameMapper') and not plain:
2748
159
            return self.genNameMapperVar(nameChunks)
2749
160
        else:
2750
161
            return self.genPlainVar(nameChunks)
2751
162
2752
163
    def addGetTextVar(self, nameChunks):
2753
164
        """Output something that gettext can recognize.
2754
165
        
2755
166
        This is a harmless side effect necessary to make gettext work when it
2756
167
        is scanning compiled templates for strings marked for translation.
2757
168
2758
169
        @@TR: another marginally more efficient approach would be to put the
2759
170
        output in a dummy method that is never called.
2760
171
        """
2761
172
        # @@TR: this should be in the compiler not here
2762
173
        self.addChunk("if False:")
2763
174
        self.indent()
2764
175
        self.addChunk(self.genPlainVar(nameChunks[:]))
2765
176
        self.dedent()
2766
177
2767
178
    def genPlainVar(self, nameChunks):        
2768
179
        """Generate Python code for a Cheetah $var without using NameMapper
2769
180
        (Unified Dotted Notation with the SearchList).
2770
181
        """
2771
182
        nameChunks.reverse()
2772
183
        chunk = nameChunks.pop()
2773
184
        pythonCode = chunk[0] + chunk[2]
2774
185
        while nameChunks:
2775
186
            chunk = nameChunks.pop()
2776
187
            pythonCode = (pythonCode + '.' + chunk[0] + chunk[2])
2777
188
        return pythonCode
2778
189
2779
190
    def genNameMapperVar(self, nameChunks):
2780
191
        """Generate valid Python code for a Cheetah $var, using NameMapper
2781
192
        (Unified Dotted Notation with the SearchList).
2782
193
2783
194
        nameChunks = list of var subcomponents represented as tuples
2784
195
          [ (name,useAC,remainderOfExpr),
2785
196
          ]
2786
197
        where:
2787
198
          name = the dotted name base
2788
199
          useAC = where NameMapper should use autocalling on namemapperPart
2789
200
          remainderOfExpr = any arglist, index, or slice
2790
201
2791
202
        If remainderOfExpr contains a call arglist (e.g. '(1234)') then useAC
2792
203
        is False, otherwise it defaults to True. It is overridden by the global
2793
204
        setting 'useAutocalling' if this setting is False.
2794
205
2795
206
        EXAMPLE
2796
207
        ------------------------------------------------------------------------
2797
208
        if the raw Cheetah Var is
2798
209
          $a.b.c[1].d().x.y.z
2799
210
          
2800
211
        nameChunks is the list
2801
212
          [ ('a.b.c',True,'[1]'), # A
2802
213
            ('d',False,'()'),     # B
2803
214
            ('x.y.z',True,''),    # C
2804
215
          ]
2805
216
        
2806
217
        When this method is fed the list above it returns
2807
218
          VFN(VFN(VFFSL(SL, 'a.b.c',True)[1], 'd',False)(), 'x.y.z',True)
2808
219
        which can be represented as
2809
220
          VFN(B`, name=C[0], executeCallables=(useAC and C[1]))C[2]
2810
221
        where:
2811
222
          VFN = NameMapper.valueForName
2812
223
          VFFSL = NameMapper.valueFromFrameOrSearchList
2813
224
          VFSL = NameMapper.valueFromSearchList # optionally used instead of VFFSL
2814
225
          SL = self.searchList()
2815
226
          useAC = self.setting('useAutocalling') # True in this example
2816
227
          
2817
228
          A = ('a.b.c',True,'[1]')
2818
229
          B = ('d',False,'()')
2819
230
          C = ('x.y.z',True,'')
2820
231
2821
232
          C` = VFN( VFN( VFFSL(SL, 'a.b.c',True)[1],
2822
233
                         'd',False)(),
2823
234
                    'x.y.z',True)
2824
235
             = VFN(B`, name='x.y.z', executeCallables=True)
2825
236
             
2826
237
          B` = VFN(A`, name=B[0], executeCallables=(useAC and B[1]))B[2]
2827
238
          A` = VFFSL(SL, name=A[0], executeCallables=(useAC and A[1]))A[2]
2828
239
2829
240
2830
241
        Note, if the compiler setting useStackFrames=False (default is true)
2831
242
        then
2832
243
          A` = VFSL([locals()]+SL+[globals(), __builtin__], name=A[0], executeCallables=(useAC and A[1]))A[2]
2833
244
        This option allows Cheetah to be used with Psyco, which doesn't support
2834
245
        stack frame introspection.
2835
246
        """
2836
247
        defaultUseAC = self.setting('useAutocalling')
2837
248
        useSearchList = self.setting('useSearchList')
2838
249
2839
250
        nameChunks.reverse()
2840
251
        name, useAC, remainder = nameChunks.pop()
2841
252
        
2842
253
        if not useSearchList:
2843
254
            firstDotIdx = name.find('.')
2844
255
            if firstDotIdx != -1 and firstDotIdx < len(name):
2845
256
                beforeFirstDot, afterDot = name[:firstDotIdx], name[firstDotIdx+1:]
2846
257
                pythonCode = ('VFN(' + beforeFirstDot +
2847
258
                              ',"' + afterDot +
2848
259
                              '",' + repr(defaultUseAC and useAC) + ')'
2849
260
                              + remainder)
2850
261
            else:
2851
262
                pythonCode = name+remainder
2852
263
        elif self.setting('useStackFrames'):
2853
264
            pythonCode = ('VFFSL(SL,'
2854
265
                          '"'+ name + '",'
2855
266
                          + repr(defaultUseAC and useAC) + ')'
2856
267
                          + remainder)
2857
268
        else:
2858
269
            pythonCode = ('VFSL([locals()]+SL+[globals(), builtin],'
2859
270
                          '"'+ name + '",'
2860
271
                          + repr(defaultUseAC and useAC) + ')'
2861
272
                          + remainder)
2862
273
        ##    
2863
274
        while nameChunks:
2864
275
            name, useAC, remainder = nameChunks.pop()
2865
276
            pythonCode = ('VFN(' + pythonCode +
2866
277
                          ',"' + name +
2867
278
                          '",' + repr(defaultUseAC and useAC) + ')'
2868
279
                          + remainder)
2869
280
        return pythonCode
2870
281
    
2871
282
##################################################
2872
283
## METHOD COMPILERS
2873
284
2874
285
class MethodCompiler(GenUtils):
2875
286
    def __init__(self, methodName, classCompiler,
2876
287
                 initialMethodComment=None,
2877
288
                 decorators=None):
2878
289
        self._settingsManager = classCompiler
2879
290
        self._classCompiler = classCompiler
2880
291
        self._moduleCompiler = classCompiler._moduleCompiler
2881
292
        self._methodName = methodName
2882
293
        self._initialMethodComment = initialMethodComment
2883
294
        self._setupState()
2884
295
        self._decorators = decorators or []
2885
296
2886
297
    def setting(self, key):
2887
298
        return self._settingsManager.setting(key)
2888
299
2889
300
    def _setupState(self):
2890
301
        self._indent = self.setting('indentationStep')
2891
302
        self._indentLev = self.setting('initialMethIndentLevel')
2892
303
        self._pendingStrConstChunks = []
2893
304
        self._methodSignature = None
2894
305
        self._methodDef = None
2895
306
        self._docStringLines = []
2896
307
        self._methodBodyChunks = []
2897
308
2898
309
        self._cacheRegionsStack = []
2899
310
        self._callRegionsStack = []
2900
311
        self._captureRegionsStack = []
2901
312
        self._filterRegionsStack = []
2902
313
2903
314
        self._isErrorCatcherOn = False
2904
315
2905
316
        self._hasReturnStatement = False
2906
317
        self._isGenerator = False
2907
318
        
2908
319
        
2909
320
    def cleanupState(self):
2910
321
        """Called by the containing class compiler instance
2911
322
        """
2912
323
        pass
2913
324
2914
325
    def methodName(self):
2915
326
        return self._methodName
2916
327
2917
328
    def setMethodName(self, name):
2918
329
        self._methodName = name
2919
330
        
2920
331
    ## methods for managing indentation
2921
332
    
2922
333
    def indentation(self):
2923
334
        return self._indent * self._indentLev
2924
335
    
2925
336
    def indent(self):
2926
337
        self._indentLev +=1
2927
338
        
2928
339
    def dedent(self):
2929
340
        if self._indentLev:
2930
341
            self._indentLev -=1
2931
342
        else:
2932
343
            raise Error('Attempt to dedent when the indentLev is 0')
2933
344
2934
345
    ## methods for final code wrapping
2935
346
2936
347
    def methodDef(self):
2937
348
        if self._methodDef:
2938
349
            return self._methodDef
2939
350
        else:
2940
351
            return self.wrapCode()
2941
352
2942
353
    __str__ = methodDef
2943
354
    __unicode__ = methodDef
2944
355
    
2945
356
    def wrapCode(self):
2946
357
        self.commitStrConst()
2947
358
        methodDefChunks = (
2948
359
            self.methodSignature(),
2949
360
            '\n',
2950
361
            self.docString(),
2951
362
            self.methodBody() )
2952
363
        methodDef = ''.join(methodDefChunks)
2953
364
        self._methodDef = methodDef
2954
365
        return methodDef
2955
366
2956
367
    def methodSignature(self):
2957
368
        return self._indent + self._methodSignature + ':'
2958
369
2959
370
    def setMethodSignature(self, signature):
2960
371
        self._methodSignature = signature
2961
372
2962
373
    def methodBody(self):
2963
374
        return ''.join( self._methodBodyChunks )
2964
375
2965
376
    def docString(self):
2966
377
        if not self._docStringLines:
2967
378
            return ''
2968
379
        
2969
380
        ind = self._indent*2        
2970
381
        docStr = (ind + '"""\n' + ind +
2971
382
                  ('\n' + ind).join([ln.replace('"""', "'''") for ln in self._docStringLines]) +
2972
383
                  '\n' + ind + '"""\n')
2973
384
        return  docStr
2974
385
2975
386
    ## methods for adding code
2976
387
    def addMethDocString(self, line):
2977
388
        self._docStringLines.append(line.replace('%', '%%'))
2978
389
       
2979
390
    def addChunk(self, chunk):
2980
391
        self.commitStrConst()
2981
392
        chunk = "\n" + self.indentation() + chunk
2982
393
        self._methodBodyChunks.append(chunk)
2983
394
2984
395
    def appendToPrevChunk(self, appendage):
2985
396
        self._methodBodyChunks[-1] = self._methodBodyChunks[-1] + appendage
2986
397
2987
398
    def addWriteChunk(self, chunk):
2988
399
        self.addChunk('write(' + chunk + ')')
2989
400
2990
401
    def addFilteredChunk(self, chunk, filterArgs=None, rawExpr=None, lineCol=None):
2991
402
        if filterArgs is None:
2992
403
            filterArgs = ''
2993
404
        if self.setting('includeRawExprInFilterArgs') and rawExpr:
2994
405
            filterArgs += ', rawExpr=%s'%repr(rawExpr)
2995
406
2996
407
        if self.setting('alwaysFilterNone'):
2997
408
            if rawExpr and rawExpr.find('\n')==-1 and rawExpr.find('\r')==-1:
2998
409
                self.addChunk("_v = %s # %r"%(chunk, rawExpr))
2999
410
                if lineCol:
3000
411
                    self.appendToPrevChunk(' on line %s, col %s'%lineCol)
3001
412
            else:
3002
413
                self.addChunk("_v = %s"%chunk)
3003
414
                
3004
415
            if self.setting('useFilters'):
3005
416
                self.addChunk("if _v is not None: write(_filter(_v%s))"%filterArgs)
3006
417
            else:
3007
418
                self.addChunk("if _v is not None: write(str(_v))")
3008
419
        else:
3009
420
            if self.setting('useFilters'):
3010
421
                self.addChunk("write(_filter(%s%s))"%(chunk, filterArgs))
3011
422
            else:
3012
423
                self.addChunk("write(str(%s))"%chunk)
3013
424
3014
425
    def _appendToPrevStrConst(self, strConst):
3015
426
        if self._pendingStrConstChunks:
3016
427
            self._pendingStrConstChunks.append(strConst)
3017
428
        else:
3018
429
            self._pendingStrConstChunks = [strConst]
3019
430
3020
431
    def commitStrConst(self):
3021
432
        """Add the code for outputting the pending strConst without chopping off
3022
433
        any whitespace from it.
3023
434
        """
3024
435
        if not self._pendingStrConstChunks:
3025
436
            return
3026
437
3027
438
        strConst = ''.join(self._pendingStrConstChunks)
3028
439
        self._pendingStrConstChunks = []
3029
440
        if not strConst:
3030
441
            return
3031
442
3032
443
        reprstr = repr(strConst)
3033
444
        i = 0
3034
445
        out = []
3035
446
        if reprstr.startswith('u'):
3036
447
            i = 1
3037
448
            out = ['u']
3038
449
        body = escapedNewlineRE.sub('\\1\n', reprstr[i+1:-1])
3039
450
        
3040
451
        if reprstr[i]=="'":
3041
452
            out.append("'''")
3042
453
            out.append(body)
3043
454
            out.append("'''")
3044
455
        else:
3045
456
            out.append('"""')
3046
457
            out.append(body)
3047
458
            out.append('"""')
3048
459
        self.addWriteChunk(''.join(out))
3049
460
3050
461
    def handleWSBeforeDirective(self):
3051
462
        """Truncate the pending strCont to the beginning of the current line.
3052
463
        """
3053
464
        if self._pendingStrConstChunks:
3054
465
            src = self._pendingStrConstChunks[-1]
3055
466
            BOL = max(src.rfind('\n')+1, src.rfind('\r')+1, 0)
3056
467
            if BOL < len(src):
3057
468
                self._pendingStrConstChunks[-1] = src[:BOL]
3058
469
3059
470
3060
471
3061
472
    def isErrorCatcherOn(self):
3062
473
        return self._isErrorCatcherOn
3063
474
    
3064
475
    def turnErrorCatcherOn(self):
3065
476
        self._isErrorCatcherOn = True
3066
477
3067
478
    def turnErrorCatcherOff(self):
3068
479
        self._isErrorCatcherOn = False
3069
480
            
3070
481
    # @@TR: consider merging the next two methods into one
3071
482
    def addStrConst(self, strConst):
3072
483
        self._appendToPrevStrConst(strConst)
3073
484
3074
485
    def addRawText(self, text):
3075
486
        self.addStrConst(text)
3076
487
        
3077
488
    def addMethComment(self, comm):
3078
489
        offSet = self.setting('commentOffset')
3079
490
        self.addChunk('#' + ' '*offSet + comm)
3080
491
3081
492
    def addPlaceholder(self, expr, filterArgs, rawPlaceholder,
3082
493
                       cacheTokenParts, lineCol,
3083
494
                       silentMode=False):
3084
495
        cacheInfo = self.genCacheInfo(cacheTokenParts)
3085
496
        if cacheInfo:
3086
497
            cacheInfo['ID'] = repr(rawPlaceholder)[1:-1]
3087
498
            self.startCacheRegion(cacheInfo, lineCol, rawPlaceholder=rawPlaceholder)
3088
499
3089
500
        if self.isErrorCatcherOn():
3090
501
            methodName = self._classCompiler.addErrorCatcherCall(
3091
502
                expr, rawCode=rawPlaceholder, lineCol=lineCol)
3092
503
            expr = 'self.' + methodName + '(localsDict=locals())' 
3093
504
3094
505
        if silentMode:
3095
506
            self.addChunk('try:')
3096
507
            self.indent()            
3097
508
            self.addFilteredChunk(expr, filterArgs, rawPlaceholder, lineCol=lineCol)
3098
509
            self.dedent()
3099
510
            self.addChunk('except NotFound: pass')            
3100
511
        else:
3101
512
            self.addFilteredChunk(expr, filterArgs, rawPlaceholder, lineCol=lineCol)
3102
513
3103
514
        if self.setting('outputRowColComments'):
3104
515
            self.appendToPrevChunk(' # from line %s, col %s' % lineCol + '.')
3105
516
        if cacheInfo:
3106
517
            self.endCacheRegion()
3107
518
3108
519
    def addSilent(self, expr):
3109
520
        self.addChunk( expr )
3110
521
3111
522
    def addEcho(self, expr, rawExpr=None):
3112
523
        self.addFilteredChunk(expr, rawExpr=rawExpr)
3113
524
        
3114
525
    def addSet(self, expr, exprComponents, setStyle):
3115
526
        if setStyle is SET_GLOBAL:
3116
527
            (LVALUE, OP, RVALUE) = (exprComponents.LVALUE,
3117
528
                                    exprComponents.OP,
3118
529
                                    exprComponents.RVALUE)
3119
530
            # we need to split the LVALUE to deal with globalSetVars
3120
531
            splitPos1 = LVALUE.find('.')
3121
532
            splitPos2 = LVALUE.find('[')
3122
533
            if splitPos1 > 0 and splitPos2==-1:
3123
534
                splitPos = splitPos1
3124
535
            elif splitPos1 > 0 and splitPos1 < max(splitPos2, 0):
3125
536
                splitPos = splitPos1
3126
537
            else:
3127
538
                splitPos = splitPos2
3128
539
3129
540
            if splitPos >0:
3130
541
                primary = LVALUE[:splitPos]
3131
542
                secondary = LVALUE[splitPos:]
3132
543
            else:
3133
544
                primary = LVALUE
3134
545
                secondary = ''            
3135
546
            LVALUE = 'self._CHEETAH__globalSetVars["' + primary + '"]' + secondary
3136
547
            expr = LVALUE + ' ' + OP + ' ' + RVALUE.strip()
3137
548
3138
549
        if setStyle is SET_MODULE:
3139
550
            self._moduleCompiler.addModuleGlobal(expr)
3140
551
        else:
3141
552
            self.addChunk(expr)
3142
553
3143
554
    def addInclude(self, sourceExpr, includeFrom, isRaw):
3144
555
        self.addChunk('self._handleCheetahInclude(' + sourceExpr +
3145
556
                           ', trans=trans, ' +
3146
557
                           'includeFrom="' + includeFrom + '", raw=' +
3147
558
                           repr(isRaw) + ')')
3148
559
3149
560
    def addWhile(self, expr, lineCol=None):
3150
561
        self.addIndentingDirective(expr, lineCol=lineCol)
3151
562
        
3152
563
    def addFor(self, expr, lineCol=None):
3153
564
        self.addIndentingDirective(expr, lineCol=lineCol)
3154
565
3155
566
    def addRepeat(self, expr, lineCol=None):
3156
567
        #the _repeatCount stuff here allows nesting of #repeat directives        
3157
568
        self._repeatCount = getattr(self, "_repeatCount", -1) + 1
3158
569
        self.addFor('for __i%s in range(%s)' % (self._repeatCount, expr), lineCol=lineCol)
3159
570
3160
571
    def addIndentingDirective(self, expr, lineCol=None):
3161
572
        if expr and not expr[-1] == ':':
3162
573
            expr = expr  + ':'
3163
574
        self.addChunk( expr )
3164
575
        if lineCol:
3165
576
            self.appendToPrevChunk(' # generated from line %s, col %s'%lineCol )
3166
577
        self.indent()
3167
578
3168
579
    def addReIndentingDirective(self, expr, dedent=True, lineCol=None):
3169
580
        self.commitStrConst()
3170
581
        if dedent:
3171
582
            self.dedent()
3172
583
        if not expr[-1] == ':':
3173
584
            expr = expr  + ':'
3174
585
            
3175
586
        self.addChunk( expr )
3176
587
        if lineCol:
3177
588
            self.appendToPrevChunk(' # generated from line %s, col %s'%lineCol )
3178
589
        self.indent()
3179
590
3180
591
    def addIf(self, expr, lineCol=None):
3181
592
        """For a full #if ... #end if directive
3182
593
        """
3183
594
        self.addIndentingDirective(expr, lineCol=lineCol)
3184
595
3185
596
    def addOneLineIf(self, expr, lineCol=None):
3186
597
        """For a full #if ... #end if directive
3187
598
        """
3188
599
        self.addIndentingDirective(expr, lineCol=lineCol)
3189
600
3190
601
    def addTernaryExpr(self, conditionExpr, trueExpr, falseExpr, lineCol=None):
3191
602
        """For a single-lie #if ... then .... else ... directive
3192
603
        <condition> then <trueExpr> else <falseExpr>
3193
604
        """
3194
605
        self.addIndentingDirective(conditionExpr, lineCol=lineCol)            
3195
606
        self.addFilteredChunk(trueExpr)
3196
607
        self.dedent()
3197
608
        self.addIndentingDirective('else')            
3198
609
        self.addFilteredChunk(falseExpr)
3199
610
        self.dedent()
3200
611
3201
612
    def addElse(self, expr, dedent=True, lineCol=None):
3202
613
        expr = re.sub(r'else[ \f\t]+if', 'elif', expr)
3203
614
        self.addReIndentingDirective(expr, dedent=dedent, lineCol=lineCol)
3204
615
3205
616
    def addElif(self, expr, dedent=True, lineCol=None):
3206
617
        self.addElse(expr, dedent=dedent, lineCol=lineCol)
3207
618
        
3208
619
    def addUnless(self, expr, lineCol=None):
3209
620
        self.addIf('if not (' + expr + ')')
3210
621
3211
622
    def addClosure(self, functionName, argsList, parserComment):
3212
623
        argStringChunks = []
3213
624
        for arg in argsList:
3214
625
            chunk = arg[0]
3215
626
            if not arg[1] == None:
3216
627
                chunk += '=' + arg[1]
3217
628
            argStringChunks.append(chunk)
3218
629
        signature = "def " + functionName + "(" + ','.join(argStringChunks) + "):"
3219
630
        self.addIndentingDirective(signature)
3220
631
        self.addChunk('#'+parserComment)
3221
632
3222
633
    def addTry(self, expr, lineCol=None):
3223
634
        self.addIndentingDirective(expr, lineCol=lineCol)
3224
635
        
3225
636
    def addExcept(self, expr, dedent=True, lineCol=None):
3226
637
        self.addReIndentingDirective(expr, dedent=dedent, lineCol=lineCol)
3227
638
        
3228
639
    def addFinally(self, expr, dedent=True, lineCol=None):
3229
640
        self.addReIndentingDirective(expr, dedent=dedent, lineCol=lineCol)
3230
641
            
3231
642
    def addReturn(self, expr):
3232
643
        assert not self._isGenerator
3233
644
        self.addChunk(expr)
3234
645
        self._hasReturnStatement = True
3235
646
3236
647
    def addYield(self, expr):
3237
648
        assert not self._hasReturnStatement
3238
649
        self._isGenerator = True
3239
650
        if expr.replace('yield', '').strip():
3240
651
            self.addChunk(expr)
3241
652
        else:
3242
653
            self.addChunk('if _dummyTrans:')
3243
654
            self.indent()
3244
655
            self.addChunk('yield trans.response().getvalue()')
3245
656
            self.addChunk('trans = DummyTransaction()')
3246
657
            self.addChunk('write = trans.response().write')
3247
658
            self.dedent()
3248
659
            self.addChunk('else:')
3249
660
            self.indent()
3250
661
            self.addChunk(
3251
662
                'raise TypeError("This method cannot be called with a trans arg")')
3252
663
            self.dedent()
3253
664
            
3254
665
3255
666
    def addPass(self, expr):
3256
667
        self.addChunk(expr)
3257
668
3258
669
    def addDel(self, expr):
3259
670
        self.addChunk(expr)
3260
671
3261
672
    def addAssert(self, expr):
3262
673
        self.addChunk(expr)
3263
674
3264
675
    def addRaise(self, expr):
3265
676
        self.addChunk(expr)
3266
677
3267
678
    def addBreak(self, expr):
3268
679
        self.addChunk(expr)
3269
680
3270
681
    def addContinue(self, expr):
3271
682
        self.addChunk(expr)
3272
683
3273
684
    def addPSP(self, PSP):
3274
685
        self.commitStrConst()
3275
686
        autoIndent = False
3276
687
        if PSP[0] == '=':
3277
688
            PSP = PSP[1:]
3278
689
            if PSP:
3279
690
                self.addWriteChunk('_filter(' + PSP + ')')
3280
691
            return
3281
692
                    
3282
693
        elif PSP.lower() == 'end':
3283
694
            self.dedent()
3284
695
            return
3285
696
        elif PSP[-1] == '$':
3286
697
            autoIndent = True
3287
698
            PSP = PSP[:-1]
3288
699
        elif PSP[-1] == ':':
3289
700
            autoIndent = True
3290
701
            
3291
702
        for line in PSP.splitlines():
3292
703
            self.addChunk(line)
3293
704
            
3294
705
        if autoIndent:
3295
706
            self.indent()
3296
707
    
3297
708
    def nextCacheID(self):
3298
709
        return ('_'+str(random.randrange(100, 999)) 
3299
710
                + str(random.randrange(10000, 99999)))
3300
711
        
3301
712
    def startCacheRegion(self, cacheInfo, lineCol, rawPlaceholder=None):
3302
713
3303
714
        # @@TR: we should add some runtime logging to this
3304
715
        
3305
716
        ID = self.nextCacheID()
3306
717
        interval = cacheInfo.get('interval', None)
3307
718
        test = cacheInfo.get('test', None)
3308
719
        customID = cacheInfo.get('id', None)
3309
720
        if customID:
3310
721
            ID = customID
3311
722
        varyBy = cacheInfo.get('varyBy', repr(ID))
3312
723
        self._cacheRegionsStack.append(ID) # attrib of current methodCompiler
3313
724
3314
725
        # @@TR: add this to a special class var as well
3315
726
        self.addChunk('')
3316
727
3317
728
        self.addChunk('## START CACHE REGION: ID='+ID+
3318
729
                      '. line %s, col %s'%lineCol + ' in the source.')
3319
730
        
3320
731
        self.addChunk('_RECACHE_%(ID)s = False'%locals())
3321
732
        self.addChunk('_cacheRegion_%(ID)s = self.getCacheRegion(regionID='%locals()
3322
733
                      + repr(ID)
3323
734
                      + ', cacheInfo=%r'%cacheInfo
3324
735
                      + ')')
3325
736
        self.addChunk('if _cacheRegion_%(ID)s.isNew():'%locals())
3326
737
        self.indent()
3327
738
        self.addChunk('_RECACHE_%(ID)s = True'%locals())
3328
739
        self.dedent()
3329
740
        
3330
741
        self.addChunk('_cacheItem_%(ID)s = _cacheRegion_%(ID)s.getCacheItem('%locals()
3331
742
                      +varyBy+')')
3332
743
3333
744
        self.addChunk('if _cacheItem_%(ID)s.hasExpired():'%locals())
3334
745
        self.indent()
3335
746
        self.addChunk('_RECACHE_%(ID)s = True'%locals())
3336
747
        self.dedent()
3337
748
            
3338
749
        if test:
3339
750
            self.addChunk('if ' + test + ':')
3340
751
            self.indent()
3341
752
            self.addChunk('_RECACHE_%(ID)s = True'%locals())
3342
753
            self.dedent()
3343
754
3344
755
        self.addChunk('if (not _RECACHE_%(ID)s) and _cacheItem_%(ID)s.getRefreshTime():'%locals())
3345
756
        self.indent()
3346
757
        #self.addChunk('print "DEBUG"+"-"*50')
3347
758
        self.addChunk('try:')
3348
759
        self.indent()
3349
760
        self.addChunk('_output = _cacheItem_%(ID)s.renderOutput()'%locals())        
3350
761
        self.dedent()                
3351
762
        self.addChunk('except KeyError:')
3352
763
        self.indent()
3353
764
        self.addChunk('_RECACHE_%(ID)s = True'%locals())
3354
765
        #self.addChunk('print "DEBUG"+"*"*50')
3355
766
        self.dedent()                
3356
767
        self.addChunk('else:')
3357
768
        self.indent()
3358
769
        self.addWriteChunk('_output')
3359
770
        self.addChunk('del _output')
3360
771
        self.dedent()                
3361
772
3362
773
        self.dedent()                
3363
774
3364
775
        self.addChunk('if _RECACHE_%(ID)s or not _cacheItem_%(ID)s.getRefreshTime():'%locals())
3365
776
        self.indent()
3366
777
        self.addChunk('_orig_trans%(ID)s = trans'%locals())
3367
778
        self.addChunk('trans = _cacheCollector_%(ID)s = DummyTransaction()'%locals())
3368
779
        self.addChunk('write = _cacheCollector_%(ID)s.response().write'%locals())
3369
780
        if interval:
3370
781
            self.addChunk(("_cacheItem_%(ID)s.setExpiryTime(currentTime() +"%locals())
3371
782
                          + str(interval) + ")")
3372
783
        
3373
784
    def endCacheRegion(self):
3374
785
        ID = self._cacheRegionsStack.pop()
3375
786
        self.addChunk('trans = _orig_trans%(ID)s'%locals())
3376
787
        self.addChunk('write = trans.response().write')
3377
788
        self.addChunk('_cacheData = _cacheCollector_%(ID)s.response().getvalue()'%locals())
3378
789
        self.addChunk('_cacheItem_%(ID)s.setData(_cacheData)'%locals())
3379
790
        self.addWriteChunk('_cacheData')
3380
791
        self.addChunk('del _cacheData')        
3381
792
        self.addChunk('del _cacheCollector_%(ID)s'%locals())
3382
793
        self.addChunk('del _orig_trans%(ID)s'%locals())
3383
794
        self.dedent()
3384
795
        self.addChunk('## END CACHE REGION: '+ID)
3385
796
        self.addChunk('')
3386
797
3387
798
    def nextCallRegionID(self):
3388
799
        return self.nextCacheID()
3389
800
3390
801
    def startCallRegion(self, functionName, args, lineCol, regionTitle='CALL'):
3391
802
        class CallDetails(object):
3392
803
            pass
3393
804
        callDetails = CallDetails()
3394
805
        callDetails.ID = ID = self.nextCallRegionID()
3395
806
        callDetails.functionName = functionName
3396
807
        callDetails.args = args
3397
808
        callDetails.lineCol = lineCol
3398
809
        callDetails.usesKeywordArgs = False
3399
810
        self._callRegionsStack.append((ID, callDetails)) # attrib of current methodCompiler
3400
811
3401
812
        self.addChunk('## START %(regionTitle)s REGION: '%locals()
3402
813
                      +ID
3403
814
                      +' of '+functionName
3404
815
                      +' at line %s, col %s'%lineCol + ' in the source.')
3405
816
        self.addChunk('_orig_trans%(ID)s = trans'%locals())
3406
817
        self.addChunk('_wasBuffering%(ID)s = self._CHEETAH__isBuffering'%locals())
3407
818
        self.addChunk('self._CHEETAH__isBuffering = True')
3408
819
        self.addChunk('trans = _callCollector%(ID)s = DummyTransaction()'%locals())
3409
820
        self.addChunk('write = _callCollector%(ID)s.response().write'%locals())
3410
821
3411
822
    def setCallArg(self, argName, lineCol):
3412
823
        ID, callDetails = self._callRegionsStack[-1]
3413
824
        argName = str(argName)
3414
825
        if callDetails.usesKeywordArgs:
3415
826
            self._endCallArg()
3416
827
        else:
3417
828
            callDetails.usesKeywordArgs = True
3418
829
            self.addChunk('_callKws%(ID)s = {}'%locals())
3419
830
            self.addChunk('_currentCallArgname%(ID)s = %(argName)r'%locals())
3420
831
        callDetails.currentArgname = argName
3421
832
        
3422
833
    def _endCallArg(self):
3423
834
        ID, callDetails = self._callRegionsStack[-1]
3424
835
        currCallArg = callDetails.currentArgname
3425
836
        self.addChunk(('_callKws%(ID)s[%(currCallArg)r] ='
3426
837
                       ' _callCollector%(ID)s.response().getvalue()')%locals())
3427
838
        self.addChunk('del _callCollector%(ID)s'%locals())
3428
839
        self.addChunk('trans = _callCollector%(ID)s = DummyTransaction()'%locals())
3429
840
        self.addChunk('write = _callCollector%(ID)s.response().write'%locals())
3430
841
    
3431
842
    def endCallRegion(self, regionTitle='CALL'):
3432
843
        ID, callDetails = self._callRegionsStack[-1]
3433
844
        functionName, initialKwArgs, lineCol = (
3434
845
            callDetails.functionName, callDetails.args, callDetails.lineCol)
3435
846
3436
847
        def reset(ID=ID):
3437
848
            self.addChunk('trans = _orig_trans%(ID)s'%locals())
3438
849
            self.addChunk('write = trans.response().write')
3439
850
            self.addChunk('self._CHEETAH__isBuffering = _wasBuffering%(ID)s '%locals())
3440
851
            self.addChunk('del _wasBuffering%(ID)s'%locals())
3441
852
            self.addChunk('del _orig_trans%(ID)s'%locals())
3442
853
3443
854
        if not callDetails.usesKeywordArgs:
3444
855
            reset()
3445
856
            self.addChunk('_callArgVal%(ID)s = _callCollector%(ID)s.response().getvalue()'%locals())
3446
857
            self.addChunk('del _callCollector%(ID)s'%locals())
3447
858
            if initialKwArgs:
3448
859
                initialKwArgs = ', '+initialKwArgs           
3449
860
            self.addFilteredChunk('%(functionName)s(_callArgVal%(ID)s%(initialKwArgs)s)'%locals())
3450
861
            self.addChunk('del _callArgVal%(ID)s'%locals())
3451
862
        else:
3452
863
            if initialKwArgs:
3453
864
                initialKwArgs = initialKwArgs+', '
3454
865
            self._endCallArg()
3455
866
            reset()
3456
867
            self.addFilteredChunk('%(functionName)s(%(initialKwArgs)s**_callKws%(ID)s)'%locals())
3457
868
            self.addChunk('del _callKws%(ID)s'%locals())
3458
869
        self.addChunk('## END %(regionTitle)s REGION: '%locals()
3459
870
                      +ID
3460
871
                      +' of '+functionName
3461
872
                      +' at line %s, col %s'%lineCol + ' in the source.')        
3462
873
        self.addChunk('')
3463
874
        self._callRegionsStack.pop() # attrib of current methodCompiler
3464
875
3465
876
    def nextCaptureRegionID(self):
3466
877
        return self.nextCacheID()
3467
878
3468
879
    def startCaptureRegion(self, assignTo, lineCol):
3469
880
        class CaptureDetails: pass
3470
881
        captureDetails = CaptureDetails()
3471
882
        captureDetails.ID = ID = self.nextCaptureRegionID()
3472
883
        captureDetails.assignTo = assignTo
3473
884
        captureDetails.lineCol = lineCol
3474
885
        
3475
886
        self._captureRegionsStack.append((ID, captureDetails)) # attrib of current methodCompiler
3476
887
        self.addChunk('## START CAPTURE REGION: '+ID
3477
888
                      +' '+assignTo
3478
889
                      +' at line %s, col %s'%lineCol + ' in the source.')
3479
890
        self.addChunk('_orig_trans%(ID)s = trans'%locals())
3480
891
        self.addChunk('_wasBuffering%(ID)s = self._CHEETAH__isBuffering'%locals())
3481
892
        self.addChunk('self._CHEETAH__isBuffering = True')
3482
893
        self.addChunk('trans = _captureCollector%(ID)s = DummyTransaction()'%locals())
3483
894
        self.addChunk('write = _captureCollector%(ID)s.response().write'%locals())
3484
895
3485
896
    def endCaptureRegion(self):
3486
897
        ID, captureDetails = self._captureRegionsStack.pop()
3487
898
        assignTo, lineCol = (captureDetails.assignTo, captureDetails.lineCol)
3488
899
        self.addChunk('trans = _orig_trans%(ID)s'%locals())
3489
900
        self.addChunk('write = trans.response().write')
3490
901
        self.addChunk('self._CHEETAH__isBuffering = _wasBuffering%(ID)s '%locals())
3491
902
        self.addChunk('%(assignTo)s = _captureCollector%(ID)s.response().getvalue()'%locals())
3492
903
        self.addChunk('del _orig_trans%(ID)s'%locals())
3493
904
        self.addChunk('del _captureCollector%(ID)s'%locals())
3494
905
        self.addChunk('del _wasBuffering%(ID)s'%locals())
3495
906
        
3496
907
    def setErrorCatcher(self, errorCatcherName):
3497
908
        self.turnErrorCatcherOn()        
3498
909
3499
910
        self.addChunk('if self._CHEETAH__errorCatchers.has_key("' + errorCatcherName + '"):')
3500
911
        self.indent()
3501
912
        self.addChunk('self._CHEETAH__errorCatcher = self._CHEETAH__errorCatchers["' +
3502
913
            errorCatcherName + '"]')
3503
914
        self.dedent()
3504
915
        self.addChunk('else:')
3505
916
        self.indent()
3506
917
        self.addChunk('self._CHEETAH__errorCatcher = self._CHEETAH__errorCatchers["'
3507
918
                      + errorCatcherName + '"] = ErrorCatchers.'
3508
919
                      + errorCatcherName + '(self)'
3509
920
                      )
3510
921
        self.dedent()
3511
922
3512
923
    def nextFilterRegionID(self):
3513
924
        return self.nextCacheID()
3514
925
3515
926
    def setTransform(self, transformer, isKlass):
3516
927
        self.addChunk('trans = TransformerTransaction()')
3517
928
        self.addChunk('trans._response = trans.response()')
3518
929
        self.addChunk('trans._response._filter = %s' % transformer)
3519
930
        self.addChunk('write = trans._response.write')
3520
931
        
3521
932
    def setFilter(self, theFilter, isKlass):
3522
933
        class FilterDetails: 
3523
934
            pass
3524
935
        filterDetails = FilterDetails()
3525
936
        filterDetails.ID = ID = self.nextFilterRegionID()
3526
937
        filterDetails.theFilter = theFilter
3527
938
        filterDetails.isKlass = isKlass
3528
939
        self._filterRegionsStack.append((ID, filterDetails)) # attrib of current methodCompiler
3529
940
3530
941
        self.addChunk('_orig_filter%(ID)s = _filter'%locals())
3531
942
        if isKlass:
3532
943
            self.addChunk('_filter = self._CHEETAH__currentFilter = ' + theFilter.strip() +
3533
944
                          '(self).filter')
3534
945
        else:
3535
946
            if theFilter.lower() == 'none':
3536
947
                self.addChunk('_filter = self._CHEETAH__initialFilter')
3537
948
            else:
3538
949
                # is string representing the name of a builtin filter
3539
950
                self.addChunk('filterName = ' + repr(theFilter))
3540
951
                self.addChunk('if self._CHEETAH__filters.has_key("' + theFilter + '"):')
3541
952
                self.indent()
3542
953
                self.addChunk('_filter = self._CHEETAH__currentFilter = self._CHEETAH__filters[filterName]')
3543
954
                self.dedent()
3544
955
                self.addChunk('else:')
3545
956
                self.indent()
3546
957
                self.addChunk('_filter = self._CHEETAH__currentFilter'
3547
958
                              +' = \\\n\t\t\tself._CHEETAH__filters[filterName] = '
3548
959
                              + 'getattr(self._CHEETAH__filtersLib, filterName)(self).filter')
3549
960
                self.dedent()
3550
961
                
3551
962
    def closeFilterBlock(self):
3552
963
        ID, filterDetails = self._filterRegionsStack.pop()
3553
964
        #self.addChunk('_filter = self._CHEETAH__initialFilter')
3554
965
        #self.addChunk('_filter = _orig_filter%(ID)s'%locals())
3555
966
        self.addChunk('_filter = self._CHEETAH__currentFilter = _orig_filter%(ID)s'%locals())
3556
967
3557
968
class AutoMethodCompiler(MethodCompiler):
3558
969
3559
970
    def _setupState(self):
3560
971
        MethodCompiler._setupState(self)
3561
972
        self._argStringList = [ ("self", None) ]
3562
973
        self._streamingEnabled = True
3563
974
        self._isClassMethod = None
3564
975
        self._isStaticMethod = None
3565
976
3566
977
    def _useKWsDictArgForPassingTrans(self):
3567
978
        alreadyHasTransArg = [argname for argname, defval in self._argStringList
3568
979
                              if argname=='trans']
3569
980
        return (self.methodName()!='respond'
3570
981
                and not alreadyHasTransArg
3571
982
                and self.setting('useKWsDictArgForPassingTrans'))
3572
983
3573
984
    def isClassMethod(self):
3574
985
        if self._isClassMethod is None:
3575
986
            self._isClassMethod = '@classmethod' in self._decorators
3576
987
        return self._isClassMethod
3577
988
3578
989
    def isStaticMethod(self):
3579
990
        if self._isStaticMethod is None:
3580
991
            self._isStaticMethod = '@staticmethod' in self._decorators
3581
992
        return self._isStaticMethod
3582
993
    
3583
994
    def cleanupState(self):
3584
995
        MethodCompiler.cleanupState(self)
3585
996
        self.commitStrConst()
3586
997
        if self._cacheRegionsStack:
3587
998
            self.endCacheRegion()
3588
999
        if self._callRegionsStack:
3589
1000
            self.endCallRegion()
3590
1001
            
3591
1002
        if self._streamingEnabled:
3592
1003
            kwargsName = None
3593
1004
            positionalArgsListName = None
3594
1005
            for argname, defval in self._argStringList:
3595
1006
                if argname.strip().startswith('**'):
3596
1007
                    kwargsName = argname.strip().replace('**', '')
3597
1008
                    break
3598
1009
                elif argname.strip().startswith('*'):
3599
1010
                    positionalArgsListName = argname.strip().replace('*', '')
3600
1011
                    
3601
1012
            if not kwargsName and self._useKWsDictArgForPassingTrans():
3602
1013
                kwargsName = 'KWS'
3603
1014
                self.addMethArg('**KWS', None)
3604
1015
            self._kwargsName = kwargsName
3605
1016
3606
1017
            if not self._useKWsDictArgForPassingTrans():
3607
1018
                if not kwargsName and not positionalArgsListName:
3608
1019
                    self.addMethArg('trans', 'None')       
3609
1020
                else:
3610
1021
                    self._streamingEnabled = False
3611
1022
                
3612
1023
        self._indentLev = self.setting('initialMethIndentLevel')
3613
1024
        mainBodyChunks = self._methodBodyChunks
3614
1025
        self._methodBodyChunks = []
3615
1026
        self._addAutoSetupCode()
3616
1027
        self._methodBodyChunks.extend(mainBodyChunks)
3617
1028
        self._addAutoCleanupCode()
3618
1029
        
3619
1030
    def _addAutoSetupCode(self):
3620
1031
        if self._initialMethodComment:
3621
1032
            self.addChunk(self._initialMethodComment)
3622
1033
            
3623
1034
        if self._streamingEnabled and not self.isClassMethod() and not self.isStaticMethod():
3624
1035
            if self._useKWsDictArgForPassingTrans() and self._kwargsName:
3625
1036
                self.addChunk('trans = %s.get("trans")'%self._kwargsName)            
3626
1037
            self.addChunk('if (not trans and not self._CHEETAH__isBuffering'
3627
1038
                          ' and not callable(self.transaction)):')
3628
1039
            self.indent()
3629
1040
            self.addChunk('trans = self.transaction'
3630
1041
                          ' # is None unless self.awake() was called')
3631
1042
            self.dedent()
3632
1043
            self.addChunk('if not trans:')
3633
1044
            self.indent()
3634
1045
            self.addChunk('trans = DummyTransaction()')
3635
1046
            if self.setting('autoAssignDummyTransactionToSelf'):
3636
1047
                self.addChunk('self.transaction = trans')            
3637
1048
            self.addChunk('_dummyTrans = True')
3638
1049
            self.dedent()
3639
1050
            self.addChunk('else: _dummyTrans = False')
3640
1051
        else:
3641
1052
            self.addChunk('trans = DummyTransaction()')
3642
1053
            self.addChunk('_dummyTrans = True')
3643
1054
        self.addChunk('write = trans.response().write')
3644
1055
        if self.setting('useNameMapper'):
3645
1056
            argNames = [arg[0] for arg in self._argStringList]
3646
1057
            allowSearchListAsMethArg = self.setting('allowSearchListAsMethArg')            
3647
1058
            if allowSearchListAsMethArg and 'SL' in argNames:
3648
1059
                pass
3649
1060
            elif allowSearchListAsMethArg and 'searchList' in argNames:
3650
1061
                self.addChunk('SL = searchList')
3651
1062
            elif not self.isClassMethod() and not self.isStaticMethod():
3652
1063
                self.addChunk('SL = self._CHEETAH__searchList')                
3653
1064
            else:
3654
1065
                self.addChunk('SL = [KWS]')
3655
1066
        if self.setting('useFilters'):
3656
1067
            if self.isClassMethod() or self.isStaticMethod():
3657
1068
                self.addChunk('_filter = lambda x, **kwargs: unicode(x)')
3658
1069
            else:
3659
1070
                self.addChunk('_filter = self._CHEETAH__currentFilter')
3660
1071
        self.addChunk('')
3661
1072
        self.addChunk("#" *40)
3662
1073
        self.addChunk('## START - generated method body')
3663
1074
        self.addChunk('')
3664
1075
3665
1076
    def _addAutoCleanupCode(self):
3666
1077
        self.addChunk('')
3667
1078
        self.addChunk("#" *40)
3668
1079
        self.addChunk('## END - generated method body')
3669
1080
        self.addChunk('')
3670
1081
3671
1082
        if not self._isGenerator:
3672
1083
            self.addStop()
3673
1084
        self.addChunk('')
3674
1085
        
3675
1086
    def addStop(self, expr=None):
3676
1087
        self.addChunk('return _dummyTrans and trans.response().getvalue() or ""')
3677
1088
3678
1089
    def addMethArg(self, name, defVal=None):
3679
1090
        self._argStringList.append( (name, defVal) )
3680
1091
        
3681
1092
    def methodSignature(self):
3682
1093
        argStringChunks = []
3683
1094
        for arg in self._argStringList:
3684
1095
            chunk = arg[0]
3685
1096
            if chunk == 'self' and self.isClassMethod():
3686
1097
                chunk = 'cls'
3687
1098
            if chunk == 'self' and self.isStaticMethod():
3688
1099
                # Skip the "self" method for @staticmethod decorators
3689
1100
                continue
3690
1101
            if not arg[1] == None:
3691
1102
                chunk += '=' + arg[1]
3692
1103
            argStringChunks.append(chunk)
3693
1104
        argString = (', ').join(argStringChunks)
3694
1105
3695
1106
        output = []
3696
1107
        if self._decorators:
3697
1108
            output.append(''.join([self._indent + decorator + '\n'
3698
1109
                                   for decorator in self._decorators]))
3699
1110
        output.append(self._indent + "def "
3700
1111
                      + self.methodName() + "(" +
3701
1112
                      argString + "):\n\n")
3702
1113
        return ''.join(output)
3703
1114
3704
1115
3705
1116
##################################################
3706
1117
## CLASS COMPILERS
3707
1118
3708
1119
_initMethod_initCheetah = """\
3709
1120
if not self._CHEETAH__instanceInitialized:
3710
1121
    cheetahKWArgs = {}
3711
1122
    allowedKWs = 'searchList namespaces filter filtersLib errorCatcher'.split()
3712
1123
    for k,v in KWs.items():
3713
1124
        if k in allowedKWs: cheetahKWArgs[k] = v
3714
1125
    self._initCheetahInstance(**cheetahKWArgs)
3715
1126
""".replace('\n', '\n'+' '*8)
3716
1127
3717
1128
class ClassCompiler(GenUtils):
3718
1129
    methodCompilerClass = AutoMethodCompiler
3719
1130
    methodCompilerClassForInit = MethodCompiler
3720
1131
        
3721
1132
    def __init__(self, className, mainMethodName='respond',
3722
1133
                 moduleCompiler=None,
3723
1134
                 fileName=None,
3724
1135
                 settingsManager=None):
3725
1136
3726
1137
        self._settingsManager = settingsManager
3727
1138
        self._fileName = fileName
3728
1139
        self._className = className
3729
1140
        self._moduleCompiler = moduleCompiler
3730
1141
        self._mainMethodName = mainMethodName
3731
1142
        self._setupState()
3732
1143
        methodCompiler = self._spawnMethodCompiler(
3733
1144
            mainMethodName,
3734
1145
            initialMethodComment='## CHEETAH: main method generated for this template')
3735
1146
3736
1147
        self._setActiveMethodCompiler(methodCompiler)
3737
1148
        if fileName and self.setting('monitorSrcFile'):
3738
1149
            self._addSourceFileMonitoring(fileName)
3739
1150
3740
1151
    def setting(self, key):
3741
1152
        return self._settingsManager.setting(key)
3742
1153
3743
1154
    def __getattr__(self, name):
3744
1155
        """Provide access to the methods and attributes of the MethodCompiler
3745
1156
        at the top of the activeMethods stack: one-way namespace sharing
3746
1157
3747
1158
        
3748
1159
        WARNING: Use .setMethods to assign the attributes of the MethodCompiler
3749
1160
        from the methods of this class!!! or you will be assigning to attributes
3750
1161
        of this object instead."""
3751
1162
        
3752
1163
        if name in self.__dict__:
3753
1164
            return self.__dict__[name]
3754
1165
        elif hasattr(self.__class__, name):
3755
1166
            return getattr(self.__class__, name)
3756
1167
        elif self._activeMethodsList and hasattr(self._activeMethodsList[-1], name):
3757
1168
            return getattr(self._activeMethodsList[-1], name)
3758
1169
        else:
3759
1170
            raise AttributeError(name)
3760
1171
3761
1172
    def _setupState(self):
3762
1173
        self._classDef = None
3763
1174
        self._decoratorsForNextMethod = []
3764
1175
        self._activeMethodsList = []        # stack while parsing/generating
3765
1176
        self._finishedMethodsList = []      # store by order
3766
1177
        self._methodsIndex = {}      # store by name
3767
1178
        self._baseClass = 'Template'
3768
1179
        self._classDocStringLines = []
3769
1180
        # printed after methods in the gen class def:
3770
1181
        self._generatedAttribs = ['_CHEETAH__instanceInitialized = False']
3771
1182
        self._generatedAttribs.append('_CHEETAH_version = __CHEETAH_version__')
3772
1183
        self._generatedAttribs.append(
3773
1184
            '_CHEETAH_versionTuple = __CHEETAH_versionTuple__')
3774
1185
3775
1186
        if self.setting('addTimestampsToCompilerOutput'):
3776
1187
            self._generatedAttribs.append('_CHEETAH_genTime = __CHEETAH_genTime__')
3777
1188
            self._generatedAttribs.append('_CHEETAH_genTimestamp = __CHEETAH_genTimestamp__')
3778
1189
3779
1190
        self._generatedAttribs.append('_CHEETAH_src = __CHEETAH_src__')
3780
1191
        self._generatedAttribs.append(
3781
1192
            '_CHEETAH_srcLastModified = __CHEETAH_srcLastModified__')
3782
1193
3783
1194
        if self.setting('templateMetaclass'):
3784
1195
            self._generatedAttribs.append('__metaclass__ = '+self.setting('templateMetaclass'))
3785
1196
        self._initMethChunks = []        
3786
1197
        self._blockMetaData = {}
3787
1198
        self._errorCatcherCount = 0
3788
1199
        self._placeholderToErrorCatcherMap = {}
3789
1200
3790
1201
    def cleanupState(self):
3791
1202
        while self._activeMethodsList:
3792
1203
            methCompiler = self._popActiveMethodCompiler()
3793
1204
            self._swallowMethodCompiler(methCompiler)
3794
1205
        self._setupInitMethod()
3795
1206
        if self._mainMethodName == 'respond':
3796
1207
            if self.setting('setup__str__method'):
3797
1208
                self._generatedAttribs.append('def __str__(self): return self.respond()')
3798
1209
        self.addAttribute('_mainCheetahMethod_for_' + self._className +
3799
1210
                           '= ' + repr(self._mainMethodName) )
3800
1211
3801
1212
    def _setupInitMethod(self):
3802
1213
        __init__ = self._spawnMethodCompiler('__init__',
3803
1214
                                             klass=self.methodCompilerClassForInit)
3804
1215
        __init__.setMethodSignature("def __init__(self, *args, **KWs)")
3805
1216
        __init__.addChunk('super(%s, self).__init__(*args, **KWs)' % self._className)
3806
1217
        __init__.addChunk(_initMethod_initCheetah % {'className' : self._className})
3807
1218
        for chunk in self._initMethChunks:
3808
1219
            __init__.addChunk(chunk)
3809
1220
        __init__.cleanupState()
3810
1221
        self._swallowMethodCompiler(__init__, pos=0)
3811
1222
3812
1223
    def _addSourceFileMonitoring(self, fileName):
3813
1224
        # @@TR: this stuff needs auditing for Cheetah 2.0       
3814
1225
        # the first bit is added to init
3815
1226
        self.addChunkToInit('self._filePath = ' + repr(fileName))
3816
1227
        self.addChunkToInit('self._fileMtime = ' + str(getmtime(fileName)) )
3817
1228
3818
1229
        # the rest is added to the main output method of the class ('mainMethod')
3819
1230
        self.addChunk('if exists(self._filePath) and ' +
3820
1231
                      'getmtime(self._filePath) > self._fileMtime:')
3821
1232
        self.indent()
3822
1233
        self.addChunk('self._compile(file=self._filePath, moduleName='+self._className + ')')
3823
1234
        self.addChunk(
3824
1235
            'write(getattr(self, self._mainCheetahMethod_for_' + self._className +
3825
1236
            ')(trans=trans))')            
3826
1237
        self.addStop()
3827
1238
        self.dedent()
3828
1239
    
3829
1240
    def setClassName(self, name):
3830
1241
        self._className = name
3831
1242
3832
1243
    def className(self):
3833
1244
        return self._className
3834
1245
3835
1246
    def setBaseClass(self, baseClassName):
3836
1247
        self._baseClass = baseClassName
3837
1248
               
3838
1249
    def setMainMethodName(self, methodName):
3839
1250
        if methodName == self._mainMethodName:
3840
1251
            return
3841
1252
        ## change the name in the methodCompiler and add new reference
3842
1253
        mainMethod = self._methodsIndex[self._mainMethodName]
3843
1254
        mainMethod.setMethodName(methodName)
3844
1255
        self._methodsIndex[methodName] = mainMethod
3845
1256
3846
1257
        ## make sure that fileUpdate code still works properly:
3847
1258
        chunkToChange = ('write(self.' + self._mainMethodName + '(trans=trans))')
3848
1259
        chunks = mainMethod._methodBodyChunks
3849
1260
        if chunkToChange in chunks:
3850
1261
            for i in range(len(chunks)):
3851
1262
                if chunks[i] == chunkToChange:
3852
1263
                    chunks[i] = ('write(self.' + methodName + '(trans=trans))')
3853
1264
        ## get rid of the old reference and update self._mainMethodName                   
3854
1265
        del self._methodsIndex[self._mainMethodName]
3855
1266
        self._mainMethodName = methodName
3856
1267
3857
1268
    def setMainMethodArgs(self, argsList):
3858
1269
        mainMethodCompiler = self._methodsIndex[self._mainMethodName]
3859
1270
        for argName, defVal in argsList:
3860
1271
            mainMethodCompiler.addMethArg(argName, defVal)
3861
1272
        
3862
1273
          
3863
1274
    def _spawnMethodCompiler(self, methodName, klass=None, 
3864
1275
                             initialMethodComment=None):
3865
1276
        if klass is None:
3866
1277
            klass = self.methodCompilerClass
3867
1278
3868
1279
        decorators = self._decoratorsForNextMethod or []
3869
1280
        self._decoratorsForNextMethod = []
3870
1281
        methodCompiler = klass(methodName, classCompiler=self,
3871
1282
                               decorators=decorators,
3872
1283
                               initialMethodComment=initialMethodComment)
3873
1284
        self._methodsIndex[methodName] = methodCompiler
3874
1285
        return methodCompiler
3875
1286
3876
1287
    def _setActiveMethodCompiler(self, methodCompiler):
3877
1288
        self._activeMethodsList.append(methodCompiler)
3878
1289
3879
1290
    def _getActiveMethodCompiler(self):
3880
1291
        return self._activeMethodsList[-1]
3881
1292
3882
1293
    def _popActiveMethodCompiler(self):
3883
1294
        return self._activeMethodsList.pop()
3884
1295
3885
1296
    def _swallowMethodCompiler(self, methodCompiler, pos=None):
3886
1297
        methodCompiler.cleanupState()
3887
1298
        if pos==None:
3888
1299
            self._finishedMethodsList.append( methodCompiler )
3889
1300
        else:
3890
1301
            self._finishedMethodsList.insert(pos, methodCompiler)
3891
1302
        return methodCompiler
3892
1303
3893
1304
    def startMethodDef(self, methodName, argsList, parserComment):
3894
1305
        methodCompiler = self._spawnMethodCompiler(
3895
1306
            methodName, initialMethodComment=parserComment)
3896
1307
        self._setActiveMethodCompiler(methodCompiler)        
3897
1308
        for argName, defVal in argsList:
3898
1309
            methodCompiler.addMethArg(argName, defVal)
3899
1310
        
3900
1311
    def _finishedMethods(self):
3901
1312
        return self._finishedMethodsList
3902
1313
3903
1314
    def addDecorator(self, decoratorExpr):
3904
1315
        """Set the decorator to be used with the next method in the source.
3905
1316
3906
1317
        See _spawnMethodCompiler() and MethodCompiler for the details of how
3907
1318
        this is used.
3908
1319
        """
3909
1320
        self._decoratorsForNextMethod.append(decoratorExpr)
3910
1321
3911
1322
    def addClassDocString(self, line):
3912
1323
        self._classDocStringLines.append( line.replace('%', '%%')) 
3913
1324
3914
1325
    def addChunkToInit(self, chunk):
3915
1326
        self._initMethChunks.append(chunk)
3916
1327
3917
1328
    def addAttribute(self, attribExpr):
3918
1329
        ## first test to make sure that the user hasn't used any fancy Cheetah syntax
3919
1330
        #  (placeholders, directives, etc.) inside the expression 
3920
1331
        if attribExpr.find('VFN(') != -1 or attribExpr.find('VFFSL(') != -1:
3921
1332
            raise ParseError(self,
3922
1333
                             'Invalid #attr directive.' +
3923
1334
                             ' It should only contain simple Python literals.')
3924
1335
        ## now add the attribute
3925
1336
        self._generatedAttribs.append(attribExpr)
3926
1337
3927
1338
    def addSuper(self, argsList, parserComment=None):        
3928
1339
        className = self._className #self._baseClass
3929
1340
        methodName = self._getActiveMethodCompiler().methodName()
3930
1341
3931
1342
        argStringChunks = []
3932
1343
        for arg in argsList:
3933
1344
            chunk = arg[0]
3934
1345
            if not arg[1] == None:
3935
1346
                chunk += '=' + arg[1]
3936
1347
            argStringChunks.append(chunk)
3937
1348
        argString = ','.join(argStringChunks)
3938
1349
3939
1350
        self.addFilteredChunk(
3940
1351
            'super(%(className)s, self).%(methodName)s(%(argString)s)'%locals())
3941
1352
3942
1353
    def addErrorCatcherCall(self, codeChunk, rawCode='', lineCol=''):
3943
1354
        if rawCode in self._placeholderToErrorCatcherMap:
3944
1355
            methodName = self._placeholderToErrorCatcherMap[rawCode]
3945
1356
            if not self.setting('outputRowColComments'):
3946
1357
                self._methodsIndex[methodName].addMethDocString(
3947
1358
                    'plus at line %s, col %s'%lineCol)
3948
1359
            return methodName
3949
1360
3950
1361
        self._errorCatcherCount += 1
3951
1362
        methodName = '__errorCatcher' + str(self._errorCatcherCount)
3952
1363
        self._placeholderToErrorCatcherMap[rawCode] = methodName
3953
1364
        
3954
1365
        catcherMeth = self._spawnMethodCompiler(
3955
1366
            methodName,
3956
1367
            klass=MethodCompiler,
3957
1368
            initialMethodComment=('## CHEETAH: Generated from ' + rawCode +
3958
1369
                                  ' at line %s, col %s'%lineCol + '.')
3959
1370
            )        
3960
1371
        catcherMeth.setMethodSignature('def ' + methodName +
3961
1372
                                       '(self, localsDict={})')
3962
1373
                                        # is this use of localsDict right?
3963
1374
        catcherMeth.addChunk('try:')
3964
1375
        catcherMeth.indent()
3965
1376
        catcherMeth.addChunk("return eval('''" + codeChunk +
3966
1377
                             "''', globals(), localsDict)")
3967
1378
        catcherMeth.dedent()
3968
1379
        catcherMeth.addChunk('except self._CHEETAH__errorCatcher.exceptions(), e:')
3969
1380
        catcherMeth.indent()        
3970
1381
        catcherMeth.addChunk("return self._CHEETAH__errorCatcher.warn(exc_val=e, code= " +
3971
1382
                             repr(codeChunk) + " , rawCode= " +
3972
1383
                             repr(rawCode) + " , lineCol=" + str(lineCol) +")")
3973
1384
        
3974
1385
        catcherMeth.cleanupState()
3975
1386
        
3976
1387
        self._swallowMethodCompiler(catcherMeth)
3977
1388
        return methodName
3978
1389
3979
1390
    def closeDef(self):
3980
1391
        self.commitStrConst()
3981
1392
        methCompiler = self._popActiveMethodCompiler()
3982
1393
        self._swallowMethodCompiler(methCompiler)
3983
1394
3984
1395
    def closeBlock(self):
3985
1396
        self.commitStrConst()
3986
1397
        methCompiler = self._popActiveMethodCompiler()
3987
1398
        methodName = methCompiler.methodName()
3988
1399
        if self.setting('includeBlockMarkers'):
3989
1400
            endMarker = self.setting('blockMarkerEnd')
3990
1401
            methCompiler.addStrConst(endMarker[0] + methodName + endMarker[1])
3991
1402
        self._swallowMethodCompiler(methCompiler)
3992
1403
        
3993
1404
        #metaData = self._blockMetaData[methodName] 
3994
1405
        #rawDirective = metaData['raw']
3995
1406
        #lineCol = metaData['lineCol']
3996
1407
        
3997
1408
        ## insert the code to call the block, caching if #cache directive is on
3998
1409
        codeChunk = 'self.' + methodName + '(trans=trans)'
3999
1410
        self.addChunk(codeChunk)
4000
1411
        
4001
1412
        #self.appendToPrevChunk(' # generated from ' + repr(rawDirective) )
4002
1413
        #if self.setting('outputRowColComments'):
4003
1414
        #    self.appendToPrevChunk(' at line %s, col %s' % lineCol + '.')
4004
1415
4005
1416
4006
1417
    ## code wrapping methods
4007
1418
    
4008
1419
    def classDef(self):
4009
1420
        if self._classDef:
4010
1421
            return self._classDef
4011
1422
        else:
4012
1423
            return self.wrapClassDef()
4013
1424
4014
1425
    __str__ = classDef
4015
1426
    __unicode__ = classDef
4016
1427
    
4017
1428
    def wrapClassDef(self):
4018
1429
        ind = self.setting('indentationStep')
4019
1430
        classDefChunks = [self.classSignature(),
4020
1431
                          self.classDocstring(),
4021
1432
                          ]
4022
1433
        def addMethods():
4023
1434
            classDefChunks.extend([
4024
1435
                ind + '#'*50,
4025
1436
                ind + '## CHEETAH GENERATED METHODS',
4026
1437
                '\n',
4027
1438
                self.methodDefs(),
4028
1439
                ])
4029
1440
        def addAttributes():
4030
1441
            classDefChunks.extend([
4031
1442
                ind + '#'*50,
4032
1443
                ind + '## CHEETAH GENERATED ATTRIBUTES',
4033
1444
                '\n',
4034
1445
                self.attributes(),
4035
1446
                ])            
4036
1447
        if self.setting('outputMethodsBeforeAttributes'):
4037
1448
            addMethods()
4038
1449
            addAttributes()
4039
1450
        else:
4040
1451
            addAttributes()
4041
1452
            addMethods()
4042
1453
            
4043
1454
        classDef = '\n'.join(classDefChunks)
4044
1455
        self._classDef = classDef
4045
1456
        return classDef
4046
1457
4047
1458
4048
1459
    def classSignature(self):
4049
1460
        return "class %s(%s):" % (self.className(), self._baseClass)
4050
1461
        
4051
1462
    def classDocstring(self):
4052
1463
        if not self._classDocStringLines:
4053
1464
            return ''
4054
1465
        ind = self.setting('indentationStep')
4055
1466
        docStr = ('%(ind)s"""\n%(ind)s' +
4056
1467
                  '\n%(ind)s'.join(self._classDocStringLines) +
4057
1468
                  '\n%(ind)s"""\n'
4058
1469
                  ) % {'ind':ind}
4059
1470
        return  docStr
4060
1471
4061
1472
    def methodDefs(self):
4062
1473
        methodDefs = [methGen.methodDef() for methGen in self._finishedMethods()]
4063
1474
        return '\n\n'.join(methodDefs)
4064
1475
4065
1476
    def attributes(self):
4066
1477
        attribs = [self.setting('indentationStep') + str(attrib)
4067
1478
                      for attrib in self._generatedAttribs ]
4068
1479
        return '\n\n'.join(attribs)
4069
1480
  
4070
1481
class AutoClassCompiler(ClassCompiler):
4071
1482
    pass
4072
1483
4073
1484
##################################################
4074
1485
## MODULE COMPILERS
4075
1486
4076
1487
class ModuleCompiler(SettingsManager, GenUtils):
4077
1488
4078
1489
    parserClass = Parser
4079
1490
    classCompilerClass = AutoClassCompiler
4080
1491
    
4081
1492
    def __init__(self, source=None, file=None,
4082
1493
                 moduleName='DynamicallyCompiledCheetahTemplate',                 
4083
1494
                 mainClassName=None, # string
4084
1495
                 mainMethodName=None, # string
4085
1496
                 baseclassName=None, # string
4086
1497
                 extraImportStatements=None, # list of strings
4087
1498
                 settings=None # dict
4088
1499
                 ):
4089
1500
        super(ModuleCompiler, self).__init__()
4090
1501
        if settings:
4091
1502
            self.updateSettings(settings)
4092
1503
        # disable useStackFrames if the C version of NameMapper isn't compiled
4093
1504
        # it's painfully slow in the Python version and bites Windows users all
4094
1505
        # the time:
4095
1506
        if not NameMapper.C_VERSION:
4096
1507
            if not sys.platform.startswith('java'):
4097
1508
                warnings.warn(
4098
1509
                    "\nYou don't have the C version of NameMapper installed! "
4099
1510
                    "I'm disabling Cheetah's useStackFrames option as it is "
4100
1511
                    "painfully slow with the Python version of NameMapper. "
4101
1512
                    "You should get a copy of Cheetah with the compiled C version of NameMapper."
4102
1513
                    )
4103
1514
            self.setSetting('useStackFrames', False)                    
4104
1515
4105
1516
        self._compiled = False
4106
1517
        self._moduleName = moduleName
4107
1518
        if not mainClassName:
4108
1519
            self._mainClassName = moduleName
4109
1520
        else:
4110
1521
            self._mainClassName = mainClassName
4111
1522
        self._mainMethodNameArg = mainMethodName
4112
1523
        if mainMethodName:
4113
1524
            self.setSetting('mainMethodName', mainMethodName)
4114
1525
        self._baseclassName = baseclassName
4115
1526
        
4116
1527
        self._filePath = None
4117
1528
        self._fileMtime = None
4118
1529
        
4119
1530
        if source and file:
4120
1531
            raise TypeError("Cannot compile from a source string AND file.")
4121
1532
        elif isinstance(file, basestring): # it's a filename.
4122
1533
            f = open(file) # Raises IOError.
4123
1534
            source = f.read()
4124
1535
            f.close()
4125
1536
            self._filePath = file
4126
1537
            self._fileMtime = os.path.getmtime(file)
4127
1538
        elif hasattr(file, 'read'):
4128
1539
            source = file.read()  # Can't set filename or mtime--they're not accessible.
4129
1540
        elif file:
4130
1541
            raise TypeError("'file' argument must be a filename string or file-like object")
4131
1542
                
4132
1543
        if self._filePath:
4133
1544
            self._fileDirName, self._fileBaseName = os.path.split(self._filePath)
4134
1545
            self._fileBaseNameRoot, self._fileBaseNameExt = os.path.splitext(self._fileBaseName)
4135
1546
4136
1547
        if not isinstance(source, basestring):
4137
1548
            source = unicode(source)
4138
1549
            # by converting to string here we allow objects such as other Templates
4139
1550
            # to be passed in
4140
1551
4141
1552
        # Handle the #indent directive by converting it to other directives.
4142
1553
        # (Over the long term we'll make it a real directive.)
4143
1554
        if source == "":
4144
1555
            warnings.warn("You supplied an empty string for the source!", )
4145
1556
        
4146
1557
        else:
4147
1558
            unicodeMatch = unicodeDirectiveRE.search(source)
4148
1559
            encodingMatch = encodingDirectiveRE.search(source)
4149
1560
            if unicodeMatch:
4150
1561
                if encodingMatch:
4151
1562
                    raise ParseError(
4152
1563
                        self, "#encoding and #unicode are mutually exclusive! "
4153
1564
                        "Use one or the other.")
4154
1565
                source = unicodeDirectiveRE.sub('', source)
4155
1566
                if isinstance(source, str):
4156
1567
                    encoding = unicodeMatch.group(1) or 'ascii'
4157
1568
                    source = unicode(source, encoding)
4158
1569
            elif encodingMatch:
4159
1570
                encodings = encodingMatch.groups()
4160
1571
                if len(encodings):
4161
1572
                    encoding = encodings[0]
4162
1573
                    source = source.decode(encoding)
4163
1574
            else:
4164
1575
                source = unicode(source)
4165
1576
4166
1577
        if source.find('#indent') != -1: #@@TR: undocumented hack
4167
1578
            source = indentize(source)
4168
1579
4169
1580
        self._parser = self.parserClass(source, filename=self._filePath, compiler=self)
4170
1581
        self._setupCompilerState()
4171
1582
        
4172
1583
    def __getattr__(self, name):
4173
1584
        """Provide one-way access to the methods and attributes of the
4174
1585
        ClassCompiler, and thereby the MethodCompilers as well.
4175
1586
4176
1587
        WARNING: Use .setMethods to assign the attributes of the ClassCompiler
4177
1588
        from the methods of this class!!! or you will be assigning to attributes
4178
1589
        of this object instead.
4179
1590
        """
4180
1591
        if name in self.__dict__:
4181
1592
            return self.__dict__[name]
4182
1593
        elif hasattr(self.__class__, name):
4183
1594
            return getattr(self.__class__, name)
4184
1595
        elif self._activeClassesList and hasattr(self._activeClassesList[-1], name):
4185
1596
            return getattr(self._activeClassesList[-1], name)
4186
1597
        else:
4187
1598
            raise AttributeError(name)
4188
1599
4189
1600
    def _initializeSettings(self):
4190
1601
        self.updateSettings(copy.deepcopy(DEFAULT_COMPILER_SETTINGS))
4191
1602
        
4192
1603
    def _setupCompilerState(self):
4193
1604
        self._activeClassesList = []
4194
1605
        self._finishedClassesList = []      # listed by ordered 
4195
1606
        self._finishedClassIndex = {}  # listed by name
4196
1607
        self._moduleDef = None
4197
1608
        self._moduleShBang = '#!/usr/bin/env python'
4198
1609
        self._moduleEncoding = 'ascii'
4199
1610
        self._moduleEncodingStr = ''
4200
1611
        self._moduleHeaderLines = []
4201
1612
        self._moduleDocStringLines = []
4202
1613
        self._specialVars = {}
4203
1614
        self._importStatements = [
4204
1615
            "import sys",
4205
1616
            "import os",
4206
1617
            "import os.path",
4207
1618
            'try:',
4208
1619
            '    import builtins as builtin',
4209
1620
            'except ImportError:',
4210
1621
            '    import __builtin__ as builtin',
4211
1622
            "from os.path import getmtime, exists",
4212
1623
            "import time",
4213
1624
            "import types",
4214
1625
            "from Cheetah.Version import MinCompatibleVersion as RequiredCheetahVersion",            
4215
1626
            "from Cheetah.Version import MinCompatibleVersionTuple as RequiredCheetahVersionTuple",
4216
1627
            "from Cheetah.Template import Template",
4217
1628
            "from Cheetah.DummyTransaction import *",
4218
1629
            "from Cheetah.NameMapper import NotFound, valueForName, valueFromSearchList, valueFromFrameOrSearchList",
4219
1630
            "from Cheetah.CacheRegion import CacheRegion",
4220
1631
            "import Cheetah.Filters as Filters",
4221
1632
            "import Cheetah.ErrorCatchers as ErrorCatchers",
4222
1633
            ]        
4223
1634
4224
1635
        self._importedVarNames = ['sys',
4225
1636
                                  'os',
4226
1637
                                  'os.path',
4227
1638
                                  'time',
4228
1639
                                  'types',
4229
1640
                                  'Template',
4230
1641
                                  'DummyTransaction',
4231
1642
                                  'NotFound',
4232
1643
                                  'Filters',
4233
1644
                                  'ErrorCatchers',
4234
1645
                                  'CacheRegion',
4235
1646
                                  ]
4236
1647
        
4237
1648
        self._moduleConstants = [
4238
1649
            "VFFSL=valueFromFrameOrSearchList",
4239
1650
            "VFSL=valueFromSearchList",
4240
1651
            "VFN=valueForName",
4241
1652
            "currentTime=time.time",
4242
1653
            ]
4243
1654
        
4244
1655
    def compile(self):
4245
1656
        classCompiler = self._spawnClassCompiler(self._mainClassName)            
4246
1657
        if self._baseclassName:
4247
1658
            classCompiler.setBaseClass(self._baseclassName)
4248
1659
        self._addActiveClassCompiler(classCompiler)
4249
1660
        self._parser.parse()
4250
1661
        self._swallowClassCompiler(self._popActiveClassCompiler())
4251
1662
        self._compiled = True
4252
1663
        self._parser.cleanup()
4253
1664
        
4254
1665
    def _spawnClassCompiler(self, className, klass=None):
4255
1666
        if klass is None:
4256
1667
            klass = self.classCompilerClass
4257
1668
        classCompiler = klass(className,
4258
1669
                              moduleCompiler=self,
4259
1670
                              mainMethodName=self.setting('mainMethodName'),
4260
1671
                              fileName=self._filePath,
4261
1672
                              settingsManager=self,
4262
1673
                              )
4263
1674
        return classCompiler
4264
1675
4265
1676
    def _addActiveClassCompiler(self, classCompiler):
4266
1677
        self._activeClassesList.append(classCompiler)
4267
1678
4268
1679
    def _getActiveClassCompiler(self):
4269
1680
        return self._activeClassesList[-1]
4270
1681
4271
1682
    def _popActiveClassCompiler(self):
4272
1683
        return self._activeClassesList.pop()
4273
1684
4274
1685
    def _swallowClassCompiler(self, classCompiler):
4275
1686
        classCompiler.cleanupState()
4276
1687
        self._finishedClassesList.append( classCompiler )
4277
1688
        self._finishedClassIndex[classCompiler.className()] = classCompiler
4278
1689
        return classCompiler
4279
1690
4280
1691
    def _finishedClasses(self):
4281
1692
        return self._finishedClassesList
4282
1693
4283
1694
    def importedVarNames(self):
4284
1695
        return self._importedVarNames
4285
1696
    
4286
1697
    def addImportedVarNames(self, varNames, raw_statement=None):
4287
1698
        settings = self.settings()
4288
1699
        if not varNames:
4289
1700
            return 
4290
1701
        if not settings.get('useLegacyImportMode'):
4291
1702
            if raw_statement and getattr(self, '_methodBodyChunks'):
4292
1703
                self.addChunk(raw_statement)
4293
1704
        else:
4294
1705
            self._importedVarNames.extend(varNames)
4295
1706
4296
1707
    ## methods for adding stuff to the module and class definitions
4297
1708
4298
1709
    def setBaseClass(self, baseClassName):
4299
1710
        if self._mainMethodNameArg:
4300
1711
            self.setMainMethodName(self._mainMethodNameArg)
4301
1712
        else:
4302
1713
            self.setMainMethodName(self.setting('mainMethodNameForSubclasses'))
4303
1714
       
4304
1715
        if self.setting('handlerForExtendsDirective'):
4305
1716
            handler = self.setting('handlerForExtendsDirective')
4306
1717
            baseClassName = handler(compiler=self, baseClassName=baseClassName)
4307
1718
            self._getActiveClassCompiler().setBaseClass(baseClassName)
4308
1719
        elif (not self.setting('autoImportForExtendsDirective')
4309
1720
            or baseClassName=='object' or baseClassName in self.importedVarNames()):
4310
1721
            self._getActiveClassCompiler().setBaseClass(baseClassName)
4311
1722
            # no need to import
4312
1723
        else:
4313
1724
            ##################################################
4314
1725
            ## If the #extends directive contains a classname or modulename that isn't
4315
1726
            #  in self.importedVarNames() already, we assume that we need to add
4316
1727
            #  an implied 'from ModName import ClassName' where ModName == ClassName.
4317
1728
            #  - This is the case in WebKit servlet modules.
4318
1729
            #  - We also assume that the final . separates the classname from the
4319
1730
            #    module name.  This might break if people do something really fancy 
4320
1731
            #    with their dots and namespaces.
4321
1732
            baseclasses = baseClassName.split(',')
4322
1733
            for klass in baseclasses:
4323
1734
                chunks = klass.split('.')
4324
1735
                if len(chunks)==1:
4325
1736
                    self._getActiveClassCompiler().setBaseClass(klass)
4326
1737
                    if klass not in self.importedVarNames():
4327
1738
                        modName = klass
4328
1739
                        # we assume the class name to be the module name
4329
1740
                        # and that it's not a builtin:
4330
1741
                        importStatement = "from %s import %s" % (modName, klass)
4331
1742
                        self.addImportStatement(importStatement)
4332
1743
                        self.addImportedVarNames((klass,))
4333
1744
                else:
4334
1745
                    needToAddImport = True
4335
1746
                    modName = chunks[0]
4336
1747
                    #print chunks, ':', self.importedVarNames()
4337
1748
                    for chunk in chunks[1:-1]:
4338
1749
                        if modName in self.importedVarNames():
4339
1750
                            needToAddImport = False
4340
1751
                            finalBaseClassName = klass.replace(modName+'.', '')
4341
1752
                            self._getActiveClassCompiler().setBaseClass(finalBaseClassName)
4342
1753
                            break
4343
1754
                        else:
4344
1755
                            modName += '.'+chunk                        
4345
1756
                    if needToAddImport:
4346
1757
                        modName, finalClassName = '.'.join(chunks[:-1]), chunks[-1]                
4347
1758
                        #if finalClassName != chunks[:-1][-1]:
4348
1759
                        if finalClassName != chunks[-2]:
4349
1760
                            # we assume the class name to be the module name
4350
1761
                            modName = '.'.join(chunks)
4351
1762
                        self._getActiveClassCompiler().setBaseClass(finalClassName)                        
4352
1763
                        importStatement = "from %s import %s" % (modName, finalClassName)
4353
1764
                        self.addImportStatement(importStatement)
4354
1765
                        self.addImportedVarNames( [finalClassName,] ) 
4355
1766
            
4356
1767
    def setCompilerSetting(self, key, valueExpr):
4357
1768
        self.setSetting(key, eval(valueExpr) )
4358
1769
        self._parser.configureParser()
4359
1770
4360
1771
    def setCompilerSettings(self, keywords, settingsStr):
4361
1772
        KWs = keywords
4362
1773
        merge = True
4363
1774
        if 'nomerge' in KWs:
4364
1775
            merge = False
4365
1776
            
4366
1777
        if 'reset' in KWs:
4367
1778
            # @@TR: this is actually caught by the parser at the moment. 
4368
1779
            # subject to change in the future
4369
1780
            self._initializeSettings()
4370
1781
            self._parser.configureParser()
4371
1782
            return
4372
1783
        elif 'python' in KWs:
4373
1784
            settingsReader = self.updateSettingsFromPySrcStr
4374
1785
            # this comes from SettingsManager
4375
1786
        else:
4376
1787
            # this comes from SettingsManager
4377
1788
            settingsReader = self.updateSettingsFromConfigStr
4378
1789
4379
1790
        settingsReader(settingsStr)
4380
1791
        self._parser.configureParser()
4381
1792
        
4382
1793
    def setShBang(self, shBang):
4383
1794
        self._moduleShBang = shBang
4384
1795
    
4385
1796
    def setModuleEncoding(self, encoding):
4386
1797
        self._moduleEncoding = encoding
4387
1798
4388
1799
    def getModuleEncoding(self):
4389
1800
        return self._moduleEncoding
4390
1801
4391
1802
    def addModuleHeader(self, line):
4392
1803
        """Adds a header comment to the top of the generated module.
4393
1804
        """
4394
1805
        self._moduleHeaderLines.append(line)
4395
1806
        
4396
1807
    def addModuleDocString(self, line):        
4397
1808
        """Adds a line to the generated module docstring.
4398
1809
        """
4399
1810
        self._moduleDocStringLines.append(line)
4400
1811
4401
1812
    def addModuleGlobal(self, line):
4402
1813
        """Adds a line of global module code.  It is inserted after the import
4403
1814
        statements and Cheetah default module constants.
4404
1815
        """
4405
1816
        self._moduleConstants.append(line)
4406
1817
4407
1818
    def addSpecialVar(self, basename, contents, includeUnderscores=True):
4408
1819
        """Adds module __specialConstant__ to the module globals.
4409
1820
        """
4410
1821
        name = includeUnderscores and '__'+basename+'__' or basename
4411
1822
        self._specialVars[name] = contents.strip()
4412
1823
4413
1824
    def addImportStatement(self, impStatement):
4414
1825
        settings = self.settings()
4415
1826
        if not self._methodBodyChunks or settings.get('useLegacyImportMode'):
4416
1827
            # In the case where we are importing inline in the middle of a source block
4417
1828
            # we don't want to inadvertantly import the module at the top of the file either
4418
1829
            self._importStatements.append(impStatement)
4419
1830
4420
1831
        #@@TR 2005-01-01: there's almost certainly a cleaner way to do this!
4421
1832
        importVarNames = impStatement[impStatement.find('import') + len('import'):].split(',')
4422
1833
        importVarNames = [var.split()[-1] for var in importVarNames] # handles aliases
4423
1834
        importVarNames = [var for var in importVarNames if not var == '*']
4424
1835
        self.addImportedVarNames(importVarNames, raw_statement=impStatement) #used by #extend for auto-imports
4425
1836
4426
1837
    def addAttribute(self, attribName, expr):
4427
1838
        self._getActiveClassCompiler().addAttribute(attribName + ' =' + expr)
4428
1839
        
4429
1840
    def addComment(self, comm):
4430
1841
        if re.match(r'#+$', comm):      # skip bar comments
4431
1842
            return
4432
1843
        
4433
1844
        specialVarMatch = specialVarRE.match(comm)
4434
1845
        if specialVarMatch:
4435
1846
            # @@TR: this is a bit hackish and is being replaced with
4436
1847
            # #set module varName = ...
4437
1848
            return self.addSpecialVar(specialVarMatch.group(1),
4438
1849
                                      comm[specialVarMatch.end():])
4439
1850
        elif comm.startswith('doc:'):
4440
1851
            addLine = self.addMethDocString
4441
1852
            comm = comm[len('doc:'):].strip()
4442
1853
        elif comm.startswith('doc-method:'):
4443
1854
            addLine = self.addMethDocString
4444
1855
            comm = comm[len('doc-method:'):].strip()
4445
1856
        elif comm.startswith('doc-module:'):
4446
1857
            addLine = self.addModuleDocString
4447
1858
            comm = comm[len('doc-module:'):].strip()
4448
1859
        elif comm.startswith('doc-class:'):
4449
1860
            addLine = self.addClassDocString
4450
1861
            comm = comm[len('doc-class:'):].strip()
4451
1862
        elif comm.startswith('header:'):
4452
1863
            addLine = self.addModuleHeader
4453
1864
            comm = comm[len('header:'):].strip()
4454
1865
        else:
4455
1866
            addLine = self.addMethComment
4456
1867
4457
1868
        for line in comm.splitlines():
4458
1869
            addLine(line)
4459
1870
4460
1871
    ## methods for module code wrapping
4461
1872
    
4462
1873
    def getModuleCode(self):
4463
1874
        if not self._compiled:
4464
1875
            self.compile()
4465
1876
        if self._moduleDef:
4466
1877
            return self._moduleDef
4467
1878
        else:
4468
1879
            return self.wrapModuleDef()
4469
1880
        
4470
1881
    __str__ = getModuleCode
4471
1882
4472
1883
    def wrapModuleDef(self):
4473
1884
        self.addSpecialVar('CHEETAH_docstring', self.setting('defDocStrMsg'))
4474
1885
        self.addModuleGlobal('__CHEETAH_version__ = %r'%Version)
4475
1886
        self.addModuleGlobal('__CHEETAH_versionTuple__ = %r'%(VersionTuple,))        
4476
1887
        if self.setting('addTimestampsToCompilerOutput'):
4477
1888
            self.addModuleGlobal('__CHEETAH_genTime__ = %r'%time.time())
4478
1889
            self.addModuleGlobal('__CHEETAH_genTimestamp__ = %r'%self.timestamp())
4479
1890
        if self._filePath:
4480
1891
            timestamp = self.timestamp(self._fileMtime)
4481
1892
            self.addModuleGlobal('__CHEETAH_src__ = %r'%self._filePath)
4482
1893
            self.addModuleGlobal('__CHEETAH_srcLastModified__ = %r'%timestamp)
4483
1894
        else:
4484
1895
            self.addModuleGlobal('__CHEETAH_src__ = None')
4485
1896
            self.addModuleGlobal('__CHEETAH_srcLastModified__ = None')            
4486
1897
4487
1898
        moduleDef = """%(header)s
4488
1899
%(docstring)s
4489
1900
4490
1901
##################################################
4491
1902
## DEPENDENCIES
4492
1903
%(imports)s
4493
1904
4494
1905
##################################################
4495
1906
## MODULE CONSTANTS
4496
1907
%(constants)s
4497
1908
%(specialVars)s
4498
1909
4499
1910
if __CHEETAH_versionTuple__ < RequiredCheetahVersionTuple:
4500
1911
    raise AssertionError(
4501
1912
      'This template was compiled with Cheetah version'
4502
1913
      ' %%s. Templates compiled before version %%s must be recompiled.'%%(
4503
1914
         __CHEETAH_version__, RequiredCheetahVersion))
4504
1915
4505
1916
##################################################
4506
1917
## CLASSES
4507
1918
4508
1919
%(classes)s
4509
1920
4510
1921
## END CLASS DEFINITION
4511
1922
4512
1923
if not hasattr(%(mainClassName)s, '_initCheetahAttributes'):
4513
1924
    templateAPIClass = getattr(%(mainClassName)s, '_CHEETAH_templateClass', Template)
4514
1925
    templateAPIClass._addCheetahPlumbingCodeToClass(%(mainClassName)s)
4515
1926
4516
1927
%(footer)s
4517
1928
""" %   {'header': self.moduleHeader(),
4518
1929
         'docstring': self.moduleDocstring(),
4519
1930
         'specialVars': self.specialVars(),
4520
1931
         'imports': self.importStatements(),
4521
1932
         'constants': self.moduleConstants(),
4522
1933
         'classes': self.classDefs(),
4523
1934
         'footer': self.moduleFooter(),
4524
1935
         'mainClassName': self._mainClassName,
4525
1936
         }
4526
1937
       
4527
1938
        self._moduleDef = moduleDef
4528
1939
        return moduleDef
4529
1940
4530
1941
    def timestamp(self, theTime=None):
4531
1942
        if not theTime:
4532
1943
            theTime = time.time()
4533
1944
        return time.asctime(time.localtime(theTime))
4534
1945
    
4535
1946
    def moduleHeader(self):
4536
1947
        header = self._moduleShBang + '\n'
4537
1948
        header += self._moduleEncodingStr + '\n'
4538
1949
        if self._moduleHeaderLines:
4539
1950
            offSet = self.setting('commentOffset')
4540
1951
        
4541
1952
            header += (
4542
1953
                '#' + ' '*offSet + 
4543
1954
                ('\n#'+ ' '*offSet).join(self._moduleHeaderLines) + '\n')
4544
1955
4545
1956
        return header
4546
1957
4547
1958
    def moduleDocstring(self):
4548
1959
        if not self._moduleDocStringLines:
4549
1960
            return ''
4550
1961
        
4551
1962
        return ('"""' +
4552
1963
                '\n'.join(self._moduleDocStringLines) +
4553
1964
                '\n"""\n')
4554
1965
4555
1966
    def specialVars(self):
4556
1967
        chunks = []
4557
1968
        theVars = self._specialVars
4558
1969
        keys = sorted(theVars.keys())
4559
1970
        for key in keys:
4560
1971
            chunks.append(key + ' = ' + repr(theVars[key])  )
4561
1972
        return '\n'.join(chunks)
4562
1973
        
4563
1974
    def importStatements(self):
4564
1975
        return '\n'.join(self._importStatements)
4565
1976
        
4566
1977
    def moduleConstants(self):
4567
1978
        return '\n'.join(self._moduleConstants)
4568
1979
4569
1980
    def classDefs(self):
4570
1981
        classDefs = [klass.classDef() for klass in self._finishedClasses()]
4571
1982
        return '\n\n'.join(classDefs)
4572
1983
4573
1984
    def moduleFooter(self):
4574
1985
        return """
4575
1986
# CHEETAH was developed by Tavis Rudd and Mike Orr
4576
1987
# with code, advice and input from many other volunteers.
4577
1988
# For more information visit http://www.CheetahTemplate.org/
4578
1989
4579
1990
##################################################
4580
1991
## if run from command line:
4581
1992
if __name__ == '__main__':
4582
1993
    from Cheetah.TemplateCmdLineIface import CmdLineIface
4583
1994
    CmdLineIface(templateObj=%(className)s()).run()
4584
1995
4585
1996
""" % {'className':self._mainClassName}
4586
1997
4587
1998
4588
1999
##################################################
4589
2000
## Make Compiler an alias for ModuleCompiler
4590
2001
    
4591
2002
Compiler = ModuleCompiler
4592
0
2003
4593
=== added file 'cheetah/DirectiveAnalyzer.py'
4594
--- cheetah/DirectiveAnalyzer.py	1970-01-01 00:00:00 +0000
4595
+++ cheetah/DirectiveAnalyzer.py	2010-10-19 20:12:51 +0000
4596
@@ -0,0 +1,98 @@
4597
1
#!/usr/bin/env python
4598
2
4599
3
import os
4600
4
import pprint
4601
5
4602
6
try:
4603
7
    from functools import reduce
4604
8
except ImportError:
4605
9
    # Assume we have reduce
4606
10
    pass
4607
11
4608
12
from Cheetah import Parser
4609
13
from Cheetah import Compiler
4610
14
from Cheetah import Template
4611
15
4612
16
class Analyzer(Parser.Parser):
4613
17
    def __init__(self, *args, **kwargs):
4614
18
        self.calls = {}
4615
19
        super(Analyzer, self).__init__(*args, **kwargs)
4616
20
4617
21
    def eatDirective(self):
4618
22
        directive = self.matchDirective()
4619
23
        try:
4620
24
            self.calls[directive] += 1
4621
25
        except KeyError:
4622
26
            self.calls[directive] = 1
4623
27
        super(Analyzer, self).eatDirective()
4624
28
4625
29
class AnalysisCompiler(Compiler.ModuleCompiler):
4626
30
    parserClass = Analyzer
4627
31
4628
32
4629
33
def analyze(source):
4630
34
    klass = Template.Template.compile(source, compilerClass=AnalysisCompiler)
4631
35
    return klass._CHEETAH_compilerInstance._parser.calls
4632
36
4633
37
def main_file(f):
4634
38
    fd = open(f, 'r')
4635
39
    try:
4636
40
        print u'>>> Analyzing %s' % f
4637
41
        calls = analyze(fd.read())
4638
42
        return calls
4639
43
    finally:
4640
44
        fd.close()
4641
45
4642
46
4643
47
def _find_templates(directory, suffix):
4644
48
    for root, dirs, files in os.walk(directory):
4645
49
        for f in files:
4646
50
            if not f.endswith(suffix):
4647
51
                continue
4648
52
            yield root + os.path.sep + f
4649
53
4650
54
def _analyze_templates(iterable):
4651
55
    for template in iterable:
4652
56
        yield main_file(template)
4653
57
4654
58
def main_dir(opts):
4655
59
    results = _analyze_templates(_find_templates(opts.dir, opts.suffix))
4656
60
    totals = {}
4657
61
    for series in results:
4658
62
        if not series:
4659
63
            continue
4660
64
        for k, v in series.iteritems():
4661
65
            try:
4662
66
                totals[k] += v
4663
67
            except KeyError:
4664
68
                totals[k] = v
4665
69
    return totals
4666
70
4667
71
4668
72
def main():
4669
73
    from optparse import OptionParser
4670
74
    op = OptionParser()
4671
75
    op.add_option('-f', '--file', dest='file', default=None,
4672
76
            help='Specify a single file to analyze')
4673
77
    op.add_option('-d', '--dir', dest='dir', default=None, 
4674
78
            help='Specify a directory of templates to analyze')
4675
79
    op.add_option('--suffix', default='tmpl', dest='suffix', 
4676
80
            help='Specify a custom template file suffix for the -d option (default: "tmpl")')
4677
81
    opts, args = op.parse_args()
4678
82
4679
83
    if not opts.file and not opts.dir:
4680
84
        op.print_help()
4681
85
        return
4682
86
4683
87
    results = None
4684
88
    if opts.file:
4685
89
        results = main_file(opts.file)
4686
90
    if opts.dir:
4687
91
        results = main_dir(opts)
4688
92
4689
93
    pprint.pprint(results)
4690
94
4691
95
4692
96
if __name__ == '__main__':
4693
97
    main()
4694
98
4695
0
99
4696
=== added file 'cheetah/Django.py'
4697
--- cheetah/Django.py	1970-01-01 00:00:00 +0000
4698
+++ cheetah/Django.py	2010-10-19 20:12:51 +0000
4699
@@ -0,0 +1,16 @@
4700
1
import Cheetah.Template
4701
2
4702
3
def render(template_file, **kwargs):
4703
4
    '''
4704
5
        Cheetah.Django.render() takes the template filename 
4705
6
        (the filename should be a file in your Django 
4706
7
        TEMPLATE_DIRS)
4707
8
4708
9
        Any additional keyword arguments are passed into the 
4709
10
        template are propogated into the template's searchList
4710
11
    '''
4711
12
    import django.http
4712
13
    import django.template.loader
4713
14
    source, loader = django.template.loader.find_template_source(template_file)
4714
15
    t = Cheetah.Template.Template(source, searchList=[kwargs])
4715
16
    return django.http.HttpResponse(t.__str__())
4716
0
17
4717
=== added file 'cheetah/DummyTransaction.py'
4718
--- cheetah/DummyTransaction.py	1970-01-01 00:00:00 +0000
4719
+++ cheetah/DummyTransaction.py	2010-10-19 20:12:51 +0000
4720
@@ -0,0 +1,108 @@
4721
1
4722
2
'''
4723
3
Provides dummy Transaction and Response classes is used by Cheetah in place
4724
4
of real Webware transactions when the Template obj is not used directly as a
4725
5
Webware servlet.
4726
6
4727
7
Warning: This may be deprecated in the future, please do not rely on any 
4728
8
specific DummyTransaction or DummyResponse behavior
4729
9
'''
4730
10
4731
11
import logging
4732
12
import types
4733
13
4734
14
class DummyResponseFailure(Exception):
4735
15
    pass
4736
16
4737
17
class DummyResponse(object):
4738
18
    '''
4739
19
        A dummy Response class is used by Cheetah in place of real Webware
4740
20
        Response objects when the Template obj is not used directly as a Webware
4741
21
        servlet
4742
22
    ''' 
4743
23
    def __init__(self):
4744
24
        self._outputChunks = []
4745
25
4746
26
    def flush(self):
4747
27
        pass
4748
28
4749
29
    def safeConvert(self, chunk):
4750
30
        # Exceptionally gross, but the safest way
4751
31
        # I've found to ensure I get a legit unicode object
4752
32
        if not chunk:
4753
33
            return u''
4754
34
        if isinstance(chunk, unicode):
4755
35
            return chunk
4756
36
        try:
4757
37
            return chunk.decode('utf-8', 'strict')
4758
38
        except UnicodeDecodeError:
4759
39
            try:
4760
40
                return chunk.decode('latin-1', 'strict')
4761
41
            except UnicodeDecodeError:
4762
42
                return chunk.decode('ascii', 'ignore')
4763
43
        except AttributeError:
4764
44
            return unicode(chunk, errors='ignore')
4765
45
        return chunk
4766
46
4767
47
    def write(self, value):
4768
48
        self._outputChunks.append(value)
4769
49
4770
50
    def writeln(self, txt):
4771
51
        write(txt)
4772
52
        write('\n')
4773
53
4774
54
    def getvalue(self, outputChunks=None):
4775
55
        chunks = outputChunks or self._outputChunks
4776
56
        try:
4777
57
            return u''.join(chunks)
4778
58
        except UnicodeDecodeError, ex:
4779
59
            logging.debug('Trying to work around a UnicodeDecodeError in getvalue()')
4780
60
            logging.debug('...perhaps you could fix "%s" while you\'re debugging')
4781
61
            return ''.join((self.safeConvert(c) for c in chunks))
4782
62
4783
63
    def writelines(self, *lines):
4784
64
        ## not used
4785
65
        [self.writeln(ln) for ln in lines]
4786
66
        
4787
67
4788
68
class DummyTransaction(object):
4789
69
    '''
4790
70
        A dummy Transaction class is used by Cheetah in place of real Webware
4791
71
        transactions when the Template obj is not used directly as a Webware
4792
72
        servlet.
4793
73
4794
74
        It only provides a response object and method.  All other methods and
4795
75
        attributes make no sense in this context.
4796
76
    '''
4797
77
    def __init__(self, *args, **kwargs):
4798
78
        self._response = None
4799
79
4800
80
    def response(self, resp=None):
4801
81
        if self._response is None:
4802
82
            self._response = resp or DummyResponse()
4803
83
        return self._response
4804
84
4805
85
4806
86
class TransformerResponse(DummyResponse):
4807
87
    def __init__(self, *args, **kwargs):
4808
88
        super(TransformerResponse, self).__init__(*args, **kwargs)
4809
89
        self._filter = None
4810
90
4811
91
    def getvalue(self, **kwargs):
4812
92
        output = super(TransformerResponse, self).getvalue(**kwargs)
4813
93
        if self._filter:
4814
94
            _filter = self._filter
4815
95
            if isinstance(_filter, type):
4816
96
                _filter = _filter()
4817
97
            return _filter.filter(output)
4818
98
        return output
4819
99
4820
100
4821
101
class TransformerTransaction(object):
4822
102
    def __init__(self, *args, **kwargs):
4823
103
        self._response = None
4824
104
    def response(self):
4825
105
        if self._response:
4826
106
            return self._response
4827
107
        return TransformerResponse()
4828
108
4829
0
109
4830
=== added file 'cheetah/ErrorCatchers.py'
4831
--- cheetah/ErrorCatchers.py	1970-01-01 00:00:00 +0000
4832
+++ cheetah/ErrorCatchers.py	2010-10-19 20:12:51 +0000
4833
@@ -0,0 +1,62 @@
4834
1
# $Id: ErrorCatchers.py,v 1.7 2005/01/03 19:59:07 tavis_rudd Exp $
4835
2
"""ErrorCatcher class for Cheetah Templates
4836
3
4837
4
Meta-Data
4838
5
================================================================================
4839
6
Author: Tavis Rudd <tavis@damnsimple.com>
4840
7
Version: $Revision: 1.7 $
4841
8
Start Date: 2001/08/01
4842
9
Last Revision Date: $Date: 2005/01/03 19:59:07 $
4843
10
"""
4844
11
__author__ = "Tavis Rudd <tavis@damnsimple.com>"
4845
12
__revision__ = "$Revision: 1.7 $"[11:-2]
4846
13
4847
14
import time
4848
15
from Cheetah.NameMapper import NotFound
4849
16
4850
17
class Error(Exception):
4851
18
    pass
4852
19
4853
20
class ErrorCatcher:
4854
21
    _exceptionsToCatch = (NotFound,)
4855
22
    
4856
23
    def __init__(self, templateObj):
4857
24
        pass
4858
25
    
4859
26
    def exceptions(self):
4860
27
        return self._exceptionsToCatch
4861
28
    
4862
29
    def warn(self, exc_val, code, rawCode, lineCol):
4863
30
        return rawCode
4864
31
## make an alias
4865
32
Echo = ErrorCatcher
4866
33
4867
34
class BigEcho(ErrorCatcher):
4868
35
    def warn(self, exc_val, code, rawCode, lineCol):
4869
36
        return "="*15 + "&lt;" + rawCode + " could not be found&gt;" + "="*15
4870
37
4871
38
class KeyError(ErrorCatcher):
4872
39
    def warn(self, exc_val, code, rawCode, lineCol):
4873
40
        raise KeyError("no '%s' in this Template Object's Search List" % rawCode) 
4874
41
4875
42
class ListErrors(ErrorCatcher):
4876
43
    """Accumulate a list of errors."""
4877
44
    _timeFormat = "%c"
4878
45
    
4879
46
    def __init__(self, templateObj):
4880
47
        ErrorCatcher.__init__(self, templateObj)
4881
48
        self._errors = []
4882
49
4883
50
    def warn(self, exc_val, code, rawCode, lineCol):
4884
51
        dict = locals().copy()
4885
52
        del dict['self']
4886
53
        dict['time'] = time.strftime(self._timeFormat,
4887
54
                                     time.localtime(time.time()))
4888
55
        self._errors.append(dict)
4889
56
        return rawCode
4890
57
    
4891
58
    def listErrors(self):
4892
59
        """Return the list of errors."""
4893
60
        return self._errors
4894
61
4895
62
4896
0
63
4897
=== added file 'cheetah/FileUtils.py'
4898
--- cheetah/FileUtils.py	1970-01-01 00:00:00 +0000
4899
+++ cheetah/FileUtils.py	2010-10-19 20:12:51 +0000
4900
@@ -0,0 +1,357 @@
4901
1
4902
2
from glob import glob
4903
3
import os
4904
4
from os import listdir
4905
5
import os.path
4906
6
import re
4907
7
from tempfile import mktemp
4908
8
4909
9
def _escapeRegexChars(txt,
4910
10
                     escapeRE=re.compile(r'([\$\^\*\+\.\?\{\}\[\]\(\)\|\\])')):
4911
11
    return escapeRE.sub(r'\\\1', txt)
4912
12
4913
13
def findFiles(*args, **kw):
4914
14
    """Recursively find all the files matching a glob pattern.
4915
15
4916
16
    This function is a wrapper around the FileFinder class.  See its docstring
4917
17
    for details about the accepted arguments, etc."""
4918
18
    
4919
19
    return FileFinder(*args, **kw).files()
4920
20
            
4921
21
def replaceStrInFiles(files, theStr, repl):
4922
22
4923
23
    """Replace all instances of 'theStr' with 'repl' for each file in the 'files'
4924
24
    list. Returns a dictionary with data about the matches found.
4925
25
4926
26
    This is like string.replace() on a multi-file basis.
4927
27
4928
28
    This function is a wrapper around the FindAndReplace class. See its
4929
29
    docstring for more details."""
4930
30
    
4931
31
    pattern = _escapeRegexChars(theStr)
4932
32
    return FindAndReplace(files, pattern, repl).results()
4933
33
4934
34
def replaceRegexInFiles(files, pattern, repl):
4935
35
4936
36
    """Replace all instances of regex 'pattern' with 'repl' for each file in the
4937
37
    'files' list. Returns a dictionary with data about the matches found.
4938
38
4939
39
    This is like re.sub on a multi-file basis.
4940
40
4941
41
    This function is a wrapper around the FindAndReplace class. See its
4942
42
    docstring for more details."""
4943
43
4944
44
    return FindAndReplace(files, pattern, repl).results()
4945
45
4946
46
4947
47
##################################################
4948
48
## CLASSES
4949
49
4950
50
class FileFinder:
4951
51
    
4952
52
    """Traverses a directory tree and finds all files in it that match one of
4953
53
    the specified glob patterns."""
4954
54
    
4955
55
    def __init__(self, rootPath,
4956
56
                 globPatterns=('*',),
4957
57
                 ignoreBasenames=('CVS', '.svn'),
4958
58
                 ignoreDirs=(),
4959
59
                 ):
4960
60
        
4961
61
        self._rootPath = rootPath
4962
62
        self._globPatterns = globPatterns
4963
63
        self._ignoreBasenames = ignoreBasenames
4964
64
        self._ignoreDirs = ignoreDirs
4965
65
        self._files = []
4966
66
        
4967
67
        self.walkDirTree(rootPath)
4968
68
            
4969
69
    def walkDirTree(self, dir='.',
4970
70
                    
4971
71
                    listdir=os.listdir,
4972
72
                    isdir=os.path.isdir,
4973
73
                    join=os.path.join,
4974
74
                    ):
4975
75
4976
76
        """Recursively walk through a directory tree and find matching files."""
4977
77
        processDir = self.processDir
4978
78
        filterDir = self.filterDir
4979
79
        
4980
80
        pendingDirs = [dir]
4981
81
        addDir = pendingDirs.append
4982
82
        getDir = pendingDirs.pop
4983
83
        
4984
84
        while pendingDirs:
4985
85
            dir = getDir()
4986
86
            ##  process this dir
4987
87
            processDir(dir)
4988
88
            
4989
89
            ## and add sub-dirs 
4990
90
            for baseName in listdir(dir):
4991
91
                fullPath = join(dir, baseName)
4992
92
                if isdir(fullPath):
4993
93
                    if filterDir(baseName, fullPath):
4994
94
                        addDir( fullPath )
4995
95
4996
96
    def filterDir(self, baseName, fullPath):
4997
97
        
4998
98
        """A hook for filtering out certain dirs. """
4999
99
        
5000
100
        return not (baseName in self._ignoreBasenames or
Reviewer	Date Requested	Status
Clint Byrum	2010-10-19	Pending
Ubuntu branches	2010-10-19	Pending
Review via email: mp+38883@code.launchpad.net