tincan: tincan.py comparison

comparison tincan.py @ 4:0d47859f792a draft

Finally got "hello, world" working. Still likely many bugs.

author	David Barts <n5jrn@me.com>
date	Mon, 13 May 2019 12:38:26 -0700
parents	c6902cded64d
children	31bb8400e6e3

comparison

equal deleted inserted replaced

-:c6902cded64d
+:0d47859f792a
 import os, sys
 import ast
 import binascii
 from base64 import b16encode, b16decode
+import functools
 import importlib
+from inspect import isclass
 import io
 import py_compile
 from stat import S_ISDIR, S_ISREG
 import bottle
 super().__init__(message, line)
 self.message = message
 self.line = line
 def __str__(self):
-return "Line {0}: {1}".format(self.line, self.message)
+return "line {0}: {1}".format(self.line, self.message)
 class ForwardException(TinCanException):
 """
 Raised to effect the flow control needed to do a forward (server-side
 redirect). It is ugly to do this, but other Python frameworks do and
 class ChameleonTemplate(bottle.BaseTemplate):
 def prepare(self, **options):
 from chameleon import PageTemplate, PageTemplateFile
 if self.source:
-self.tpl = chameleon.PageTemplate(self.source,
+self.tpl = PageTemplate(self.source, encoding=self.encoding,
-encoding=self.encoding, **options)
+**options)
 else:
-self.tpl = chameleon.PageTemplateFile(self.filename,
+self.tpl = PageTemplateFile(self.filename, encoding=self.encoding,
-encoding=self.encoding, search_path=self.lookup, **options)
+search_path=self.lookup, **options)
 def render(self, *args, **kwargs):
 for dictarg in args:
 kwargs.update(dictarg)
 _defaults = self.defaults.copy()
 _defaults.update(kwargs)
 return self.tpl.render(**_defaults)
-chameleon_template = functools.partial(template, template_adapter=ChameleonTemplate)
+chameleon_template = functools.partial(bottle.template, template_adapter=ChameleonTemplate)
-chameleon_view = functools.partial(view, template_adapter=ChameleonTemplate)
+chameleon_view = functools.partial(bottle.view, template_adapter=ChameleonTemplate)
 # U t i l i t i e s
 def _normpath(base, unsplit):
 """
 continue
 value = getattr(self, name)
 if callable(value):
 continue
 ret[name] = value
+return ret
 # R o u t e s
 #
 # Represents a route in TinCan. Our launcher creates these on-the-fly based
 # on the files it finds.
 _PEXTEN = ".py"
 _TEXTEN = ".pspx"
 _FLOOP = "tincan.forwards"
 _FORIG = "tincan.origin"
-class TinCanErrorRoute(object):
+class _TinCanErrorRoute(object):
 """
 A route to an error page. These never have code-behind, don't get
 routes created for them, and are only reached if an error routes them
 there. Error templates only have two variables available: e (the
 HTTPError object associated with the error) and request.
 self._template.prepare()
 def __call__(self, e):
 return self._template.render(e=e, request=bottle.request).lstrip('\n')
-class TinCanRoute(object):
+class _TinCanRoute(object):
 """
 A route created by the TinCan launcher.
 """
 def __init__(self, launcher, name, subdir):
 self._fsroot = launcher.fsroot
 self._urlroot = launcher.urlroot
 self._name = name
 self._python = name + _PEXTEN
-self._content = CONTENT
 self._fspath = os.path.join(launcher.fsroot, *subdir, name + _TEXTEN)
 self._urlpath = self._urljoin(launcher.urlroot, *subdir, name + _TEXTEN)
 self._origin = self._urlpath
 self._subdir = subdir
 self._seen = set()
 """
 # Build master and header objects, process #forward directives
 hidden = None
 while True:
 self._template = TemplateFile(self._fspath)
-self._header = TemplateHeader(self._template.header)
+try:
+self._header = TemplateHeader(self._template.header)
+except TemplateHeaderException as e:
+raise TinCanError("{0}: {1!s}".format(self._fspath, e)) from e
 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
+# If this is a #hidden page, we ignore it for now, since hidden pages
 # don't get routes made for them.
 if hidden:
 return
-# If this is an error page, register it as such.
+# 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
+# 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))
-# Process other header entries
+# 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}", self._urlpath, _PEXTEN)
+raise TinCanError("{0}: #python files must end in {1}".format(self._urlpath, _PEXTEN))
 self._python = self._header.python
 # Obtain a class object by importing and introspecting a module.
 self._getclass()
-# Build body object (Chameleon template)
+# Build body object (#template)
 if self._header.template is not None:
 if not self._header.template.endswith(_TEXTEN):
-raise TinCanError("{0}: #template files must end in {1}", self._urlpath, _TEXTEN)
+raise TinCanError("{0}: #template files must end in {1}".format(self._urlpath, _TEXTEN))
-tpath = os.path.join(self._fsroot, *self._splitpath(self._header.template))
+tpath = os.path.normpath(os.path.join(self._fsroot, *self._splitpath(self._header.template)))
 tfile = TemplateFile(tpath)
 self._body = self._tclass(source=tfile.body)
 else:
 self._body = self._tclass(source=self._template.body)
 self._body.prepare()
 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))
 for error in errors:
 if error < _ERRMIN or error > _ERRMAX:
 raise TinCanError("{0}: bad #errors code".format(self._urlpath))
 self._app.error(code=error, callback=route)
 def _getclass(self):
-pypath = os.path.normpath(os.path.join(self._fsroot, *self._subdir, self._python))
+pypath = os.path.normpath(os.path.join(self._fsroot, *self._splitpath(self._python)))
 pycpath = pypath + 'c'
 try:
 pyctime = os.stat(pycpath).st_mtime
 except OSError:
 pyctime = 0
-if pyctime < os.stat(pypath).st_mtime:
+try:
-try:
+if pyctime < os.stat(pypath).st_mtime:
-py_compile.compile(pypath, cfile=pycpath)
+py_compile.compile(pypath, cfile=pycpath, doraise=True)
-except Exception as e:
+except py_compile.PyCompileError as e:
-raise TinCanError("{0}: error compiling".format(pypath)) from e
+raise TinCanError(str(e)) from e
-try:
+except Exception as e:
-spec = importlib.util.spec_from_file_location(_mangle(self._name), cpath)
+raise TinCanError("{0}: {1!s}".format(pypath, e)) from e
+try:
+spec = importlib.util.spec_from_file_location(_mangle(self._name), pycpath)
 mod =  importlib.util.module_from_spec(spec)
 spec.loader.exec_module(mod)
 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 issubclass(v, Page):
+if isclass(v) and issubclass(v, Page):
 if self._class is not None:
-raise TinCanError("{0}: contains multiple Page classes", pypath)
+raise TinCanError("{0}: contains multiple Page classes".format(pypath))
 self._class = v
 if self._class is None:
-raise TinCanError("{0}: contains no Page classes", pypath)
+raise TinCanError("{0}: contains no Page classes".format(pypath))
 def _redirect(self):
-if self._header.forward in self._seen:
-raise TinCanError("{0}: #forward loop".format(self._origin))
-self._seen.add(self._header.forward)
 try:
 rlist = self._splitpath(self._header.forward)
+forw = '/' + '/'.join(rlist)
+if forw in self.seen:
+raise TinCanError("{0}: #forward loop".format(self._origin))
+self._seen.add(forw)
 rname = rlist.pop()
 except IndexError as e:
 raise TinCanError("{0}: invalid #forward".format(self._urlpath)) from e
 name, ext = os.path.splitext(rname)[1]
 if ext != _TEXTEN:
 obj.handle()
 return self._body.render(obj.export()).lstrip('\n')
 except ForwardException as fwd:
 target = fwd.target
 if target is None:
-raise TinCanError("Unexpected null target!")
+raise TinCanError("{0}: unexpected null target".format(self._urlpath))
 # We get here if we are doing a server-side programmatic
 # forward.
 environ = bottle.request.environ
 if _FORIG not in environ:
 environ[_FORIG] = self._urlpath
 if _FLOOP not in environ:
 environ[_FLOOP] = set([self._urlpath])
 elif target in environ[_FLOOP]:
-TinCanError("{0}: forward loop detected".format(environ[_FORIG]))
+raise TinCanError("{0}: forward loop detected".format(environ[_FORIG]))
 environ[_FLOOP].add(target)
 environ['bottle.raw_path'] = target
 environ['PATH_INFO'] = urllib.parse.quote(target)
 route, args = self._app.router.match(environ)
 environ['route.handle'] = environ['bottle.route'] = route
 class _Launcher(object):
 """
 Helper class for launching webapps.
 """
-def __init__(self, fsroot, urlroot, tclass):
+def __init__(self, fsroot, urlroot, tclass, logger):
 """
 Lightweight constructor. The real action happens in .launch() below.
 """
 self.fsroot = fsroot
 self.urlroot = urlroot
 self.tclass = tclass
+self.logger = logger
 self.app = None
+self.errors = 0
+self.debug = False
 def launch(self):
 """
 Does the actual work of launching something. XXX - modifies sys.path
 and never un-modifies it.
 # Add our private lib directory to sys.path
 sys.path.insert(1, os.path.abspath(lib))
 # Do what we gotta do
 self.app = TinCan()
 self._launch([])
-return self.app
+return self
 def _launch(self, subdir):
 for entry in os.listdir(os.path.join(self.fsroot, *subdir)):
 if not subdir and entry in _BANNED:
 continue
 etype = os.stat(os.path.join(self.fsroot, *subdir, entry)).st_mode
 if S_ISREG(etype):
 ename, eext = os.path.splitext(entry)
 if eext != _TEXTEN:
 continue  # only look at interesting files
-route = TinCanRoute(self, ename, subdir)
+route = _TinCanRoute(self, ename, subdir)
-page.launch()
+try:
+route.launch()
+except TinCanError as e:
+self.logger(str(e))
+if self.debug:
+while e.__cause__ != None:
+e = e.__cause__
+self.logger("\t{0}: {1!s}".format(e.__class__.__name__, e))
+self.errors += 1
 elif S_ISDIR(etype):
 self._launch(subdir + [entry])
-def launch(fsroot=None, urlroot='/', tclass=ChameleonTemplate):
+def _logger(message):
+sys.stderr.write(message)
+sys.stderr.write('\n')
+def launch(fsroot=None, urlroot='/', tclass=ChameleonTemplate, logger=_logger):
 """
 Launch and return a TinCan webapp. Does not run the app; it is the
 caller's responsibility to call app.run()
 """
 if fsroot is None:
 fsroot = os.getcwd()
-return _Launcher(fsroot, urlroot, tclass).launch()
+launcher = _Launcher(fsroot, urlroot, tclass, logger)
+# launcher.debug = True
+launcher.launch()
+return launcher.app, launcher.errors
+# XXX - We cannot implement a command-line launcher here; see the
+# launcher script for why.

Mercurial > cgi-bin > hgweb.cgi > tincan

comparison tincan.py @ 4:0d47859f792a draft