tincan: tincan.py comparison

comparison tincan.py @ 9:75e375b1976a draft

Error pages now can have code-behind.

author	David Barts <n5jrn@me.com>
date	Mon, 13 May 2019 20:47:51 -0700
parents	9aaa91247b14
children	8037bad7d5a8

comparison

equal deleted inserted replaced

-:9aaa91247b14
+:75e375b1976a
 """
 The parent class of all exceptions we raise.
 """
 pass
-class TemplateHeaderException(TinCanException):
+class TemplateHeaderError(TinCanException):
 """
 Raised upon encountering a syntax error in the template headers.
 """
 def __init__(self, message, line):
 super().__init__(message, line)
 del lines[-1]
 for line in lines:
 # Get line
 count += 1
 if not line.startswith("#"):
-raise TemplateHeaderException("Does not start with '#'.", count)
+raise TemplateHeaderError("Does not start with '#'.", count)
 try:
 rna, rpa = line.split(maxsplit=1)
 except ValueError:
 rna = line.rstrip()
 rpa = None
 if name == "rem":
 continue
 if name == "end":
 break
 if name not in nameset:
-raise TemplateHeaderException("Invalid directive: {0!r}".format(rna), count)
+raise TemplateHeaderError("Invalid directive: {0!r}".format(rna), count)
 if name in seen:
-raise TemplateHeaderException("Duplicate {0!r} directive.".format(rna), count)
+raise TemplateHeaderError("Duplicate {0!r} directive.".format(rna), count)
 seen.add(name)
 # Flags
 if name in self._FNAMES:
 setattr(self, name, True)
 continue
 # Get parameter
 if rpa is None:
-raise TemplateHeaderException("Missing parameter.", count)
+raise TemplateHeaderError("Missing parameter.", count)
 param = rpa.strip()
 for i in [ "'", '"']:
 if param.startswith(i) and param.endswith(i):
 param = ast.literal_eval(param)
 break
 """
 Forward this request to the specified target route.
 """
 source = bottle.request.environ['PATH_INFO']
 base = source.strip('/').split('/')[:-1]
+if bottle.request.environ.get(_FTYPE, False):
+raise TinCanError("{0}: forward from error page".format(source))
 try:
 exc = ForwardException('/' + '/'.join(_normpath(base, target)))
 except IndexError as e:
 raise TinCanError("{0}: invalid forward to {1!r}".format(source, target)) from e
 raise exc
 # C o d e   B e h i n d
 #
 # Represents the code-behind of one of our pages. This gets subclassed, of
 # course.
-class Page(object):
+class BasePage(object):
-# Non-private things we refuse to export anyhow.
+"""
-__HIDDEN = set([ "request", "response" ])
+The parent class of both error and normal pages.
+"""
-def __init__(self, req, resp):
-"""
-Constructor. This is a lightweight operation.
-"""
-self.request = req  # app context is request.app in Bottle
-self.response = resp
 def handle(self):
 """
 This is the entry point for the code-behind logic. It is intended
 to be overridden.
 """
 pass
 def export(self):
 """
 Export template variables. The default behavior is to export all
-non-hidden non-callables that don't start with an underscore,
+non-hidden non-callables that don't start with an underscore.
-plus a an export named page that contains this object itself.
 This method can be overridden if a different behavior is
 desired. It should always return a dict or dict-like object.
 """
-ret = { "page": self }  # feature: will be clobbered if self.page exists
+ret = { 'page': self }
 for name in dir(self):
-if name in self.__HIDDEN or name.startswith('_'):
+if name in self._HIDDEN or name.startswith('_'):
 continue
 value = getattr(self, name)
 if callable(value):
 continue
 ret[name] = value
 return ret
+class Page(BasePage):
+# Non-private things we refuse to export anyhow.
+_HIDDEN = set([ "request", "response" ])
+def __init__(self, req, resp):
+"""
+Constructor. This is a lightweight operation.
+"""
+self.request = req  # app context is request.app in Bottle
+self.response = resp
+class ErrorPage(BasePage):
+"""
+The code-behind for an error page.
+"""
+_HIDDEN = set()
+def __init__(self, req, err):
+"""
+Constructor. This is a lightweight operation.
+"""
+self.request = req
+self.error = err
 # R o u t e s
 #
 # Represents a route in TinCan. Our launcher creates these on-the-fly based
 # on the files it finds.
 _ERRMAX = 599
 _PEXTEN = ".py"
 _TEXTEN = ".pspx"
 _FLOOP = "tincan.forwards"
 _FORIG = "tincan.origin"
+_FTYPE = "tincan.iserror"
 class _TinCanErrorRoute(object):
 """
-A route to an error page. These never have code-behind, don't get
+A route to an error page. These don't get routes created for them,
-routes created for them, and are only reached if an error routes them
+and are only reached if an error routes them there. Unless you create
-there. Error templates only have two variables available: e (the
+custom code-behind, only two variables are available to your template:
-HTTPError object associated with the error) and request.
+request (bottle.Request) and error (bottle.HTTPError).
 """
-def __init__(self, template):
+def __init__(self, template, klass):
 self._template = template
 self._template.prepare()
+self._class = klass
 def __call__(self, e):
-return self._template.render(error=e, request=bottle.request).lstrip('\n')
+obj = self._class(bottle.request, e)
+obj.handle()
+return self._template.render(obj.export()).lstrip('\n')
 class _TinCanRoute(object):
 """
 A route created by the TinCan launcher.
 """
 def launch(self):
 """
 Launch a single page.
 """
 # Build master and header objects, process #forward directives
-hidden = None
+hidden = oerrors = None
 while True:
+if oerrors is not None and oerrors != self._header.errors:
+raise TinCanError("{0}: invalid redirect")
 self._template = TemplateFile(self._fspath)
 try:
 self._header = TemplateHeader(self._template.header)
-except TemplateHeaderException as e:
+except TemplateHeaderError as e:
 raise TinCanError("{0}: {1!s}".format(self._fspath, e)) from e
+oerrors = self._header.errors
 if hidden is None:
-if self._header.errors is not None:
-break
 hidden = self._header.hidden
 elif self._header.errors is not None:
 raise TinCanError("{0}: #forward to #errors not allowed".format(self._origin))
 if self._header.forward is None:
 break
 self._redirect()
 # If this is a #hidden page, we ignore it for now, since hidden pages
 # don't get routes made for them.
-if hidden:
+if hidden and not self._headers.errors:
 return
-# If this is an #errors page, register it as such.
-if self._header.errors is not None:
-self._mkerror()
-return  # this implies #hidden
-# Get #methods for this route
-if self._header.methods is None:
-methods = [ 'GET' ]
-else:
-methods = [ i.upper() for i in self._header.methods.split() ]
-if not methods:
-raise TinCanError("{0}: no #methods specified".format(self._urlpath))
 # Get the code-behind #python
 if self._header.python is not None:
 if not self._header.python.endswith(_PEXTEN):
 raise TinCanError("{0}: #python files must end in {1}".format(self._urlpath, _PEXTEN))
 self._python = self._header.python
 tfile = TemplateFile(tpath)
 self._body = self._tclass(source=tfile.body)
 else:
 self._body = self._tclass(source=self._template.body)
 self._body.prepare()
+# If this is an #errors page, register it as such.
+if self._header.errors is not None:
+self._mkerror()
+return  # this implies #hidden
+# Get #methods for this route
+if self._header.methods is None:
+methods = [ 'GET' ]
+else:
+methods = [ i.upper() for i in self._header.methods.split() ]
+if not methods:
+raise TinCanError("{0}: no #methods specified".format(self._urlpath))
 # Register this thing with Bottle
 print("adding route:", self._origin, '('+','.join(methods)+')')  # debug
 self._app.route(self._origin, methods, self)
 def _splitpath(self, unsplit):
 errors = [ int(i) for i in self._header.errors.split() ]
 except ValueError as e:
 raise TinCanError("{0}: bad #errors line".format(self._urlpath)) from e
 if not errors:
 errors = range(_ERRMIN, _ERRMAX+1)
-route = _TinCanErrorRoute(self._tclass(source=self._template.body))
+route = _TinCanErrorRoute(self._tclass(source=self._template.body), self._class)
 for error in errors:
 if error < _ERRMIN or error > _ERRMAX:
 raise TinCanError("{0}: bad #errors code".format(self._urlpath))
 self._app.error_handler[error] = route  # XXX
 try:
 return os.stat(path).st_mtime
 except FileNotFoundError:
 return 0
 except OSError as e:
-raise TinCanError("{0}: {1}".format(path, e.strerror)) from e
+raise TinCanError(str(e)) from e
 def _getclass(self):
 pypath = os.path.normpath(os.path.join(self._fsroot, *self._splitpath(self._python)))
+klass = ErrorPage if self._header.errors else Page
 # Give 'em a default code-behind if they don't furnish one
 pytime = self._gettime(pypath)
 if not pytime:
-self._class = Page
+self._class = klass
 return
 # Else load the code-behind from a .py file
 pycpath = pypath + 'c'
 pyctime = self._gettime(pycpath)
 try:
 except Exception as e:
 raise TinCanError("{0}: error importing".format(pycpath)) from e
 self._class = None
 for i in dir(mod):
 v = getattr(mod, i)
-if isclass(v) and issubclass(v, Page):
+if isclass(v) and issubclass(v, klass):
 if self._class is not None:
-raise TinCanError("{0}: contains multiple Page classes".format(pypath))
+raise TinCanError("{0}: contains multiple {1} classes".format(pypath, klass.__name__))
 self._class = v
 if self._class is None:
-raise TinCanError("{0}: contains no Page classes".format(pypath))
+raise TinCanError("{0}: contains no {1} classes".format(pypath, klass.__name__))
 def _redirect(self):
 try:
 rlist = self._splitpath(self._header.forward)
 forw = '/' + '/'.join(rlist)

Mercurial > cgi-bin > hgweb.cgi > tincan

comparison tincan.py @ 9:75e375b1976a draft