code-4e16bcd4405e/roundup/cgi/PageTemplates/Expressions.py0000644000000000000000000002534112103450444021615 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## # Modified for Roundup: # # 1. removed all Zope-specific code (doesn't even try to import that stuff now) # 2. removed all Acquisition # 3. removed blocking of leading-underscore URL components """Page Template Expression Engine Page Template-specific implementation of TALES, with handlers for Python expressions, string literals, and paths. """ import re, sys from TALES import Engine, CompilerError, _valid_name, NAME_RE, \ Undefined, Default, _parse_expr _engine = None def getEngine(): global _engine if _engine is None: from PathIterator import Iterator _engine = Engine(Iterator) installHandlers(_engine) return _engine def installHandlers(engine): reg = engine.registerType pe = PathExpr for pt in ('standard', 'path', 'exists', 'nocall'): reg(pt, pe) reg('string', StringExpr) reg('python', PythonExpr) reg('not', NotExpr) reg('defer', DeferExpr) from PythonExpr import getSecurityManager, PythonExpr guarded_getattr = getattr try: from zExceptions import Unauthorized except ImportError: class Unauthorized(Exception): pass def acquisition_security_filter(orig, inst, name, v, real_validate): if real_validate(orig, inst, name, v): return 1 raise Unauthorized, name def call_with_ns(f, ns, arg=1): if arg==2: return f(None, ns) else: return f(ns) class _SecureModuleImporter: """Simple version of the importer for use with trusted code.""" __allow_access_to_unprotected_subobjects__ = 1 def __getitem__(self, module): __import__(module) return sys.modules[module] SecureModuleImporter = _SecureModuleImporter() Undefs = (Undefined, AttributeError, KeyError, TypeError, IndexError, Unauthorized) def render(ob, ns): """ Calls the object, possibly a document template, or just returns it if not callable. (From DT_Util.py) """ if hasattr(ob, '__render_with_namespace__'): ob = call_with_ns(ob.__render_with_namespace__, ns) else: base = ob if callable(base): try: if getattr(base, 'isDocTemp', 0): ob = call_with_ns(ob, ns, 2) else: ob = ob() except AttributeError, n: if str(n) != '__call__': raise return ob class SubPathExpr: def __init__(self, path): self._path = path = path.strip().split('/') self._base = base = path.pop(0) if base and not _valid_name(base): raise CompilerError, 'Invalid variable name "%s"' % base # Parse path self._dp = dp = [] for i in range(len(path)): e = path[i] if e[:1] == '?' and _valid_name(e[1:]): dp.append((i, e[1:])) dp.reverse() def _eval(self, econtext, list=list, isinstance=isinstance, StringType=type('')): vars = econtext.vars path = self._path if self._dp: path = list(path) # Copy! for i, varname in self._dp: val = vars[varname] if isinstance(val, StringType): path[i] = val else: # If the value isn't a string, assume it's a sequence # of path names. path[i:i+1] = list(val) base = self._base __traceback_info__ = 'path expression "%s"'%('/'.join(self._path)) if base == 'CONTEXTS' or not base: ob = econtext.contexts else: ob = vars[base] if isinstance(ob, DeferWrapper): ob = ob() if path: ob = restrictedTraverse(ob, path, getSecurityManager()) return ob class PathExpr: def __init__(self, name, expr, engine): self._s = expr self._name = name self._hybrid = 0 paths = expr.split('|') self._subexprs = [] add = self._subexprs.append for i in range(len(paths)): path = paths[i].lstrip() if _parse_expr(path): # This part is the start of another expression type, # so glue it back together and compile it. add(engine.compile(('|'.join(paths[i:]).lstrip()))) self._hybrid = 1 break add(SubPathExpr(path)._eval) def _exists(self, econtext): for expr in self._subexprs: try: expr(econtext) except Undefs: pass else: return 1 return 0 def _eval(self, econtext, isinstance=isinstance, StringType=type(''), render=render): for expr in self._subexprs[:-1]: # Try all but the last subexpression, skipping undefined ones. try: ob = expr(econtext) except Undefs: pass else: break else: # On the last subexpression allow exceptions through, and # don't autocall if the expression was not a subpath. ob = self._subexprs[-1](econtext) if self._hybrid: return ob if self._name == 'nocall' or isinstance(ob, StringType): return ob # Return the rendered object return render(ob, econtext.vars) def __call__(self, econtext): if self._name == 'exists': return self._exists(econtext) return self._eval(econtext) def __str__(self): return '%s expression %s' % (self._name, `self._s`) def __repr__(self): return '%s:%s' % (self._name, `self._s`) _interp = re.compile(r'\$(%(n)s)|\${(%(n)s(?:/[^}]*)*)}' % {'n': NAME_RE}) class StringExpr: def __init__(self, name, expr, engine): self._s = expr if '%' in expr: expr = expr.replace('%', '%%') self._vars = vars = [] if '$' in expr: parts = [] for exp in expr.split('$$'): if parts: parts.append('$') m = _interp.search(exp) while m is not None: parts.append(exp[:m.start()]) parts.append('%s') vars.append(PathExpr('path', m.group(1) or m.group(2), engine)) exp = exp[m.end():] m = _interp.search(exp) if '$' in exp: raise CompilerError, ( '$ must be doubled or followed by a simple path') parts.append(exp) expr = ''.join(parts) self._expr = expr def __call__(self, econtext): vvals = [] for var in self._vars: v = var(econtext) # I hope this isn't in use anymore. ## if isinstance(v, Exception): ## raise v vvals.append(v) return self._expr % tuple(vvals) def __str__(self): return 'string expression %s' % `self._s` def __repr__(self): return 'string:%s' % `self._s` class NotExpr: def __init__(self, name, expr, compiler): self._s = expr = expr.lstrip() self._c = compiler.compile(expr) def __call__(self, econtext): # We use the (not x) and 1 or 0 formulation to avoid changing # the representation of the result in Python 2.3, where the # result of "not" becomes an instance of bool. return (not econtext.evaluateBoolean(self._c)) and 1 or 0 def __repr__(self): return 'not:%s' % `self._s` class DeferWrapper: def __init__(self, expr, econtext): self._expr = expr self._econtext = econtext def __str__(self): return str(self()) def __call__(self): return self._expr(self._econtext) class DeferExpr: def __init__(self, name, expr, compiler): self._s = expr = expr.lstrip() self._c = compiler.compile(expr) def __call__(self, econtext): return DeferWrapper(self._c, econtext) def __repr__(self): return 'defer:%s' % `self._s` class TraversalError: def __init__(self, path, name): self.path = path self.name = name def restrictedTraverse(object, path, securityManager, get=getattr, has=hasattr, N=None, M=[], TupleType=type(()) ): REQUEST = {'path': path} REQUEST['TraversalRequestNameStack'] = path = path[:] # Copy! path.reverse() validate = securityManager.validate __traceback_info__ = REQUEST done = [] while path: name = path.pop() __traceback_info__ = TraversalError(done, name) if isinstance(name, TupleType): object = object(*name) continue if not name: # Skip directly to item access o = object[name] # Check access to the item. if not validate(object, object, name, o): raise Unauthorized, name object = o continue # Try an attribute. o = guarded_getattr(object, name, M) if o is M: # Try an item. try: # XXX maybe in Python 2.2 we can just check whether # the object has the attribute "__getitem__" # instead of blindly catching exceptions. o = object[name] except AttributeError, exc: if str(exc).find('__getitem__') >= 0: # The object does not support the item interface. # Try to re-raise the original attribute error. # XXX I think this only happens with # ExtensionClass instances. guarded_getattr(object, name) raise except TypeError, exc: if str(exc).find('unsubscriptable') >= 0: # The object does not support the item interface. # Try to re-raise the original attribute error. # XXX This is sooooo ugly. guarded_getattr(object, name) raise done.append((name, o)) object = o return object code-4e16bcd4405e/roundup/cgi/PageTemplates/GlobalTranslationService.py0000644000000000000000000000337012103450444024231 0ustar 00000000000000############################################################################## # # Copyright (c) 2002 Zope Corporation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## # Modifications for Roundup: # 1. implemented ustr as str # 2. make imports use roundup.cgi """Global Translation Service for providing I18n to Page Templates. """ import re from roundup.cgi.TAL.TALDefs import NAME_RE ustr = str class DummyTranslationService: """Translation service that doesn't know anything about translation.""" def translate(self, domain, msgid, mapping=None, context=None, target_language=None, default=None): def repl(m, mapping=mapping): return ustr(mapping[m.group(m.lastindex)]) cre = re.compile(r'\$(?:(%s)|\{(%s)\})' % (NAME_RE, NAME_RE)) return cre.sub(repl, default or msgid) # XXX Not all of Zope.I18n.ITranslationService is implemented. translationService = DummyTranslationService() def setGlobalTranslationService(service): """Sets the global translation service, and returns the previous one.""" global translationService old_service = translationService translationService = service return old_service def getGlobalTranslationService(): """Returns the global translation service.""" return translationService code-4e16bcd4405e/roundup/cgi/PageTemplates/MultiMapping.py0000644000000000000000000000151712103450444021700 0ustar 00000000000000import operator class MultiMapping: def __init__(self, *stores): self.stores = list(stores) def __getitem__(self, key): for store in self.stores: if store.has_key(key): return store[key] raise KeyError, key _marker = [] def get(self, key, default=_marker): for store in self.stores: if store.has_key(key): return store[key] if default is self._marker: raise KeyError, key return default def __len__(self): return reduce(operator.add, [len(x) for x in self.stores], 0) def push(self, store): self.stores.append(store) def pop(self): return self.stores.pop() def items(self): l = [] for store in self.stores: l = l + store.items() return l code-4e16bcd4405e/roundup/cgi/PageTemplates/PageTemplate.py0000644000000000000000000001526112103450444021643 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## # Modified for Roundup: # # 1. changed imports to import from roundup.cgi # 2. removed use of ExtensionClass # 3. removed use of ComputedAttribute """Page Template module HTML- and XML-based template objects using TAL, TALES, and METAL. """ import sys from roundup.cgi.TAL.TALParser import TALParser from roundup.cgi.TAL.HTMLTALParser import HTMLTALParser from roundup.cgi.TAL.TALGenerator import TALGenerator # Do not use cStringIO here! It's not unicode aware. :( from roundup.cgi.TAL.TALInterpreter import TALInterpreter, FasterStringIO from Expressions import getEngine class PageTemplate: "Page Templates using TAL, TALES, and METAL" content_type = 'text/html' expand = 0 _v_errors = () _v_warnings = () _v_program = None _v_macros = None _v_cooked = 0 id = '(unknown)' _text = '' _error_start = '') if errend >= 0: text = text[errend + 4:] if self._text != text: self._text = text self._cook() def read(self): self._cook_check() if not self._v_errors: if not self.expand: return self._text try: return self.pt_render(source=1) except: return ('%s\n Macro expansion failed\n %s\n-->\n%s' % (self._error_start, "%s: %s" % sys.exc_info()[:2], self._text) ) return ('%s\n %s\n-->\n%s' % (self._error_start, '\n '.join(self._v_errors), self._text)) def _cook_check(self): if not self._v_cooked: self._cook() def _cook(self): """Compile the TAL and METAL statments. Cooking must not fail due to compilation errors in templates. """ source_file = self.pt_source_file() if self.html(): gen = TALGenerator(getEngine(), xml=0, source_file=source_file) parser = HTMLTALParser(gen) else: gen = TALGenerator(getEngine(), source_file=source_file) parser = TALParser(gen) self._v_errors = () try: parser.parseString(self._text) self._v_program, self._v_macros = parser.getCode() except: self._v_errors = ["Compilation failed", "%s: %s" % sys.exc_info()[:2]] self._v_warnings = parser.getWarnings() self._v_cooked = 1 def html(self): if not hasattr(getattr(self, 'aq_base', self), 'is_html'): return self.content_type == 'text/html' return self.is_html class _ModuleImporter: def __getitem__(self, module): mod = __import__(module) path = module.split('.') for name in path[1:]: mod = getattr(mod, name) return mod ModuleImporter = _ModuleImporter() class PTRuntimeError(RuntimeError): '''The Page Template has template errors that prevent it from rendering.''' pass class PageTemplateTracebackSupplement: #__implements__ = ITracebackSupplement def __init__(self, pt): self.object = pt w = pt.pt_warnings() e = pt.pt_errors() if e: w = list(w) + list(e) self.warnings = w code-4e16bcd4405e/roundup/cgi/PageTemplates/PathIterator.py0000644000000000000000000000307612103450444021702 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## """Path Iterator A TALES Iterator with the ability to use first() and last() on subpaths of elements. """ import TALES from Expressions import restrictedTraverse, Undefs, getSecurityManager class Iterator(TALES.Iterator): def __bobo_traverse__(self, REQUEST, name): if name in ('first', 'last'): path = REQUEST['TraversalRequestNameStack'] names = list(path) names.reverse() path[:] = [tuple(names)] return getattr(self, name) def same_part(self, name, ob1, ob2): if name is None: return ob1 == ob2 if isinstance(name, type('')): name = name.split('/') name = filter(None, name) securityManager = getSecurityManager() try: ob1 = restrictedTraverse(ob1, name, securityManager) ob2 = restrictedTraverse(ob2, name, securityManager) except Undefs: return 0 return ob1 == ob2 code-4e16bcd4405e/roundup/cgi/PageTemplates/PythonExpr.py0000644000000000000000000000551012103450444021407 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## # Modified for Roundup: # # 1. more informative traceback info """Generic Python Expression Handler """ from TALES import CompilerError from sys import exc_info class getSecurityManager: '''Null security manager''' def validate(self, *args, **kwargs): return 1 addContext = removeContext = validateValue = validate class PythonExpr: def __init__(self, name, expr, engine): self.expr = expr = expr.strip().replace('\n', ' ') try: d = {} exec 'def f():\n return %s\n' % expr.strip() in d self._f = d['f'] except: raise CompilerError, ('Python expression error:\n' '%s: %s') % exc_info()[:2] self._get_used_names() def _get_used_names(self): self._f_varnames = vnames = [] for vname in self._f.func_code.co_names: if vname[0] not in '$_': vnames.append(vname) def _bind_used_names(self, econtext, _marker=[]): # Bind template variables names = {'CONTEXTS': econtext.contexts} vars = econtext.vars getType = econtext.getCompiler().getTypes().get for vname in self._f_varnames: val = vars.get(vname, _marker) if val is _marker: has = val = getType(vname) if has: val = ExprTypeProxy(vname, val, econtext) names[vname] = val else: names[vname] = val return names def __call__(self, econtext): __traceback_info__ = 'python expression "%s"'%self.expr f = self._f f.func_globals.update(self._bind_used_names(econtext)) return f() def __str__(self): return 'Python expression "%s"' % self.expr def __repr__(self): return '' % self.expr class ExprTypeProxy: '''Class that proxies access to an expression type handler''' def __init__(self, name, handler, econtext): self._name = name self._handler = handler self._econtext = econtext def __call__(self, text): return self._handler(self._name, text, self._econtext.getCompiler())(self._econtext) code-4e16bcd4405e/roundup/cgi/PageTemplates/README.txt0000644000000000000000000000064612103450444020420 0ustar 00000000000000See the ZPT project Wiki for more information about Page Templates, or the download page for installation instructions and the most recent version of the software. This Product requires the TAL and ZTUtils packages to be installed in your Python path (not Products). See the links above for more information. code-4e16bcd4405e/roundup/cgi/PageTemplates/TALES.py0000644000000000000000000002174412103450444020146 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## # Modified for Roundup: # # 1. changed imports to import from roundup.cgi # 2. implemented ustr as str (removes import from DocumentTemplate) # 3. removed import and use of Unauthorized from zExceptions """TALES An implementation of a generic TALES engine """ import re, sys from roundup.cgi import ZTUtils from weakref import ref from MultiMapping import MultiMapping from GlobalTranslationService import getGlobalTranslationService ustr = str StringType = type('') NAME_RE = r"[a-zA-Z][a-zA-Z0-9_]*" _parse_expr = re.compile(r"(%s):" % NAME_RE).match _valid_name = re.compile('%s$' % NAME_RE).match class TALESError(Exception): """Error during TALES expression evaluation""" class Undefined(TALESError): '''Exception raised on traversal of an undefined path''' class RegistrationError(Exception): '''TALES Type Registration Error''' class CompilerError(Exception): '''TALES Compiler Error''' class Default: '''Retain Default''' Default = Default() class SafeMapping(MultiMapping): '''Mapping with security declarations and limited method exposure. Since it subclasses MultiMapping, this class can be used to wrap one or more mapping objects. Restricted Python code will not be able to mutate the SafeMapping or the wrapped mappings, but will be able to read any value. ''' __allow_access_to_unprotected_subobjects__ = 1 push = pop = None _push = MultiMapping.push _pop = MultiMapping.pop class Iterator(ZTUtils.Iterator): def __init__(self, name, seq, context): ZTUtils.Iterator.__init__(self, seq) self.name = name self._context_ref = ref(context) def next(self): if ZTUtils.Iterator.next(self): context = self._context_ref() if context is not None: context.setLocal(self.name, self.item) return 1 return 0 class ErrorInfo: """Information about an exception passed to an on-error handler.""" __allow_access_to_unprotected_subobjects__ = 1 def __init__(self, err, position=(None, None)): if isinstance(err, Exception): self.type = err.__class__ self.value = err else: self.type = err self.value = None self.lineno = position[0] self.offset = position[1] class Engine: '''Expression Engine An instance of this class keeps a mutable collection of expression type handlers. It can compile expression strings by delegating to these handlers. It can provide an expression Context, which is capable of holding state and evaluating compiled expressions. ''' Iterator = Iterator def __init__(self, Iterator=None): self.types = {} if Iterator is not None: self.Iterator = Iterator def registerType(self, name, handler): if not _valid_name(name): raise RegistrationError, 'Invalid Expression type "%s".' % name types = self.types if types.has_key(name): raise RegistrationError, ( 'Multiple registrations for Expression type "%s".' % name) types[name] = handler def getTypes(self): return self.types def compile(self, expression): m = _parse_expr(expression) if m: type = m.group(1) expr = expression[m.end():] else: type = "standard" expr = expression try: handler = self.types[type] except KeyError: raise CompilerError, ( 'Unrecognized expression type "%s".' % type) return handler(type, expr, self) def getContext(self, contexts=None, **kwcontexts): if contexts is not None: if kwcontexts: kwcontexts.update(contexts) else: kwcontexts = contexts return Context(self, kwcontexts) def getCompilerError(self): return CompilerError class Context: '''Expression Context An instance of this class holds context information that it can use to evaluate compiled expressions. ''' _context_class = SafeMapping position = (None, None) source_file = None def __init__(self, compiler, contexts): self._compiler = compiler self.contexts = contexts contexts['nothing'] = None contexts['default'] = Default self.repeat_vars = rv = {} # Wrap this, as it is visible to restricted code contexts['repeat'] = rep = self._context_class(rv) contexts['loop'] = rep # alias self.global_vars = gv = contexts.copy() self.local_vars = lv = {} self.vars = self._context_class(gv, lv) # Keep track of what needs to be popped as each scope ends. self._scope_stack = [] def getCompiler(self): return self._compiler def beginScope(self): self._scope_stack.append([self.local_vars.copy()]) def endScope(self): scope = self._scope_stack.pop() self.local_vars = lv = scope[0] v = self.vars v._pop() v._push(lv) # Pop repeat variables, if any i = len(scope) - 1 while i: name, value = scope[i] if value is None: del self.repeat_vars[name] else: self.repeat_vars[name] = value i = i - 1 def setLocal(self, name, value): self.local_vars[name] = value def setGlobal(self, name, value): self.global_vars[name] = value def setRepeat(self, name, expr): expr = self.evaluate(expr) if not expr: return self._compiler.Iterator(name, (), self) it = self._compiler.Iterator(name, expr, self) old_value = self.repeat_vars.get(name) self._scope_stack[-1].append((name, old_value)) self.repeat_vars[name] = it return it def evaluate(self, expression, isinstance=isinstance, StringType=StringType): if isinstance(expression, StringType): expression = self._compiler.compile(expression) __traceback_supplement__ = ( TALESTracebackSupplement, self, expression) return expression(self) evaluateValue = evaluate evaluateBoolean = evaluate def evaluateText(self, expr): text = self.evaluate(expr) if text is Default or text is None: return text if isinstance(text, unicode): return text else: return ustr(text) def evaluateStructure(self, expr): return self.evaluate(expr) evaluateStructure = evaluate def evaluateMacro(self, expr): # XXX Should return None or a macro definition return self.evaluate(expr) evaluateMacro = evaluate def createErrorInfo(self, err, position): return ErrorInfo(err, position) def getDefault(self): return Default def setSourceFile(self, source_file): self.source_file = source_file def setPosition(self, position): self.position = position def translate(self, domain, msgid, mapping=None, context=None, target_language=None, default=None): if context is None: context = self.contexts.get('here') return getGlobalTranslationService().translate( domain, msgid, mapping=mapping, context=context, default=default, target_language=target_language) class TALESTracebackSupplement: """Implementation of ITracebackSupplement""" def __init__(self, context, expression): self.context = context self.source_url = context.source_file self.line = context.position[0] self.column = context.position[1] self.expression = repr(expression) def getInfo(self, as_html=0): import pprint data = self.context.contexts.copy() s = pprint.pformat(data) if not as_html: return ' - Names:\n %s' % s.replace('\n', '\n ') else: from cgi import escape return 'Names:
%s
' % (escape(s)) class SimpleExpr: '''Simple example of an expression type handler''' def __init__(self, name, expr, engine): self._name = name self._expr = expr def __call__(self, econtext): return self._name, self._expr def __repr__(self): return '' % (self._name, `self._expr`) code-4e16bcd4405e/roundup/cgi/PageTemplates/__init__.py0000644000000000000000000000174712103450444021036 0ustar 00000000000000############################################################################## # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## __doc__='''Package wrapper for Page Templates This wrapper allows the Page Template modules to be segregated in a separate package. ''' __version__='$$'[11:-2] # Placeholder for Zope Product data misc_ = {} def initialize(context): # Import lazily, and defer initialization to the module import ZopePageTemplate ZopePageTemplate.initialize(context)