""" % locals())
indent = indent_re.match(h[3])
if indent: indent = len(indent.group(1)) # noqa: E701
for line in h[3:]:
if indent:
print(line[indent:])
else:
print(line)
print('What follows is a test, not an actual exception:
") g() except: print_exception() print("Second try with a small maxlen...
") global maxlen maxlen = 50 try: form = FieldStorage() # Replace with other classes to test those print_directory() print_arguments() print_form(form) print_environ(environ) except: print_exception() def print_exception(type=None, value=None, tb=None, limit=None): if type is None: type, value, tb = sys.exc_info() import traceback print() print("Traceback (most recent call last):
") list = traceback.format_tb(tb, limit) + \ traceback.format_exception_only(type, value) print("%s%s" % ( html.escape("".join(list[:-1])), html.escape(list[-1]), )) del tb def print_environ(environ=os.environ): """Dump the shell environment as HTML.""" keys = sorted(environ.keys()) print() print("
Shell Environment:
") print("- ")
for key in keys:
print("
- ", html.escape(key), "
- ", html.escape(environ[key])) print("
Form Contents:
") if not keys: print("No form fields.") print("
- ")
for key in keys:
print("
- " + html.escape(key) + ":", end=' ') value = form[key] print("" + html.escape(repr(type(value))) + "") print("
- " + html.escape(repr(value))) print("
Current Working Directory:
") try: pwd = os.getcwd() except OSError as msg: print("OSError:", html.escape(str(msg))) else: print(html.escape(pwd)) print() def print_arguments(): print() print("Command Line Arguments:
") print() print(sys.argv) print() def print_environ_usage(): """Dump a list of environment variables used by CGI as HTML.""" print("""These environment variables could have been set:
- AUTH_TYPE
- CONTENT_LENGTH
- CONTENT_TYPE
- DATE_GMT
- DATE_LOCAL
- DOCUMENT_NAME
- DOCUMENT_ROOT
- DOCUMENT_URI
- GATEWAY_INTERFACE
- LAST_MODIFIED
- PATH
- PATH_INFO
- PATH_TRANSLATED
- QUERY_STRING
- REMOTE_ADDR
- REMOTE_HOST
- REMOTE_IDENT
- REMOTE_USER
- REQUEST_METHOD
- SCRIPT_NAME
- SERVER_NAME
- SERVER_PORT
- SERVER_PROTOCOL
- SERVER_ROOT
- SERVER_SOFTWARE
- HTTP_ACCEPT
- HTTP_CONNECTION
- HTTP_HOST
- HTTP_PRAGMA
- HTTP_REFERER
- HTTP_USER_AGENT
Keyword Expression Editor:
''' def list_nodes(request): prop = request.form.getfirst("property") cls = request.client.db.getclass(prop) items = [] for nodeid in cls.getnodeids(retired=0): l = cls.getnode(nodeid).items() l = dict([x for x in l if len(x) == 2]) try: items.append((l['id'], l['name'])) except KeyError: pass items.sort(key=lambda x: int(x[0])) return items def items_to_keywords(items): return ',\n '.join(['["%s", "%s"]' % x for x in items]) def render_keywords_expression_editor(request): prop = request.form.getfirst("property") window_content = WINDOW_CONTENT % { 'prop': prop, 'keywords': items_to_keywords(list_nodes(request)), 'original': '', 'nonce': request.client.client_nonce } return window_content # vim: set et sts=4 sw=4 : code-a4cb4e75d4e9/roundup/cgi/PageTemplates/Expressions.py 0000644 0000000 0000000 00000025570 14644345424 021730 0 ustar 0000000 0000000 ############################################################################## # # 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 try: from collections.abc import Callable except ImportError: from collections import Callable 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(BaseException): 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 isinstance(base, Callable): try: if getattr(base, 'isDocTemp', 0): ob = call_with_ns(ob, ns, 2) else: ob = ob() except AttributeError as 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, repr(self._s)) def __repr__(self): return '%s:%s' % (self._name, repr(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' % repr(self._s) def __repr__(self): return 'string:%s' % repr(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' % repr(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' % repr(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 as 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 as 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-a4cb4e75d4e9/roundup/cgi/PageTemplates/GlobalTranslationService.py 0000644 0000000 0000000 00000002672 14644345424 024344 0 ustar 0000000 0000000 ############################################################################## # # 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 # 3. stripped GlobalTranslationService of everything except # DummyTranslationService """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. code-a4cb4e75d4e9/roundup/cgi/PageTemplates/MultiMapping.py 0000644 0000000 0000000 00000001465 14644345424 022011 0 ustar 0000000 0000000 import operator class MultiMapping: def __init__(self, *stores): self.stores = list(stores) def __getitem__(self, key): for store in self.stores: if key in store: return store[key] raise KeyError(key) _marker = [] def get(self, key, default=_marker): for store in self.stores: if key in store: return store[key] if default is self._marker: raise KeyError(key) return default def __len__(self): return sum([len(x) for x in self.stores]) 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 + list(store.items()) return l code-a4cb4e75d4e9/roundup/cgi/PageTemplates/PageTemplate.py 0000644 0000000 0000000 00000015210 14644345424 021744 0 ustar 0000000 0000000 ############################################################################## # # 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 from roundup.cgi.TAL.TALInterpreter import TALInterpreter from .Expressions import getEngine from roundup.anypy.strings import StringIO 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-a4cb4e75d4e9/roundup/cgi/PageTemplates/PathIterator.py 0000644 0000000 0000000 00000003114 14644345424 022002 0 ustar 0000000 0000000 ############################################################################## # # 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. """ from . 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 = list(filter(None, name)) securityManager = getSecurityManager() try: ob1 = restrictedTraverse(ob1, name, securityManager) ob2 = restrictedTraverse(ob2, name, securityManager) except Undefs: return 0 return ob1 == ob2 code-a4cb4e75d4e9/roundup/cgi/PageTemplates/PythonExpr.py 0000644 0000000 0000000 00000007071 14644345424 021522 0 ustar 0000000 0000000 ############################################################################## # # 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 """ import symtable 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 = {} self.f_code = 'def f():\n return %s\n' % expr.strip() exec(self.f_code, 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._get_from_symtab(): if vname[0] not in '$_.': vnames.append(vname) def _get_from_symtab(self): """ Get the variables used in the 'f' function. """ variables = set() table = symtable.symtable(self.f_code, "
%s' % (html_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 '
', 'endtag': '
'} timings['seconds'] = time.time()-self.start s = self._( '%(starttag)sTime elapsed: %(seconds)fs%(endtag)s\n' ) % timings if hasattr(self.db, 'stats'): timings.update(self.db.stats) s += self._("%(starttag)sCache hits: %(cache_hits)d," " misses %(cache_misses)d." " Loading items: %(get_items)f secs." " Filtering: %(filtering)f secs." "%(endtag)s\n") % timings s += '