tincan: tincan.py comparison

comparison tincan.py @ 25:e93e5e746cc5 draft header-includes

Preliminary debugging, still not fully tested.

author	David Barts <n5jrn@me.com>
date	Sun, 26 May 2019 11:43:48 -0700
parents	34d3cfcd37ef
children	cc6ba7834294

comparison

equal deleted inserted replaced

-:34d3cfcd37ef
+:e93e5e746cc5
 """
 The parent class of all exceptions we raise.
 """
 pass
-class BaseSyntaxError(TinCanException):
 class TemplateHeaderError(TinCanException):
 """
 Raised upon encountering a syntax error in the template headers.
 """
 def __init__(self, message, line):
 super().__init__(message, source)
 self.message = message
 self.source = source
 def __str__(self):
-return "{0}: {1}".format(self.source, self.message)
+return "{0}: #include error: {1}".format(self.source, 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
 self._state(line)
 return
 if line.startswith(self._END) and (len(line) == self._LEND or line[self._LEND] in self._WS):
 self._state = self._body
 self._hbuf.append(line)
-self._bbuf.append("\n")
 def _body(self, line):
 self._bbuf.append(line)
 class TemplateHeader(object):
 # Initialize our state
 for i in self._NAMES:
 setattr(self, i, None)
 for i in self._FNAMES:
 setattr(self, i, False)
+for i in self._ANAMES:
+setattr(self, i, [])
 # Parse the string
 count = 0
-nameset = set(self._NAMES + self._FNAMES)
+nameset = set(self._NAMES + self._FNAMES + self._ANAMES)
 seen = set()
 lines = string.split("\n")
 if lines and lines[-1] == "":
 del lines[-1]
 for line in lines:
 self.subdir = subdir
 self.name = name
 self.included = set() if included is None else included
 self.encoding = encoding
 self._buf = []
-self._tlib = os.path.join(base, _WINF, "tlib")
 def render(self, includes, body):
 for i in includes:
 if i.startswith('<') and i.endswith('>'):
-self._buf.append(self._render1(self._tlib, i[1:-1]))
+self._buf.append(self._render1([_WINF, "tlib"], i[1:-1]))
 else:
 self._buf.append(self._render1(self.subdir, i))
 self._buf.append(body)
 return ''.join(self._buf)
 def _render1(self, subdir, path):
 # Reject bad file names
-if not path.endswith(_IEXTEN) or path.endswith(_PEXTEN):
+if not path.endswith(_IEXTEN) or path.endswith(_TEXTEN):
-raise IncludeError(self.name, "#include files must end with {0} or {1}".format(_IEXTEN, _PEXTEN))
+raise IncludeError("file names must end with {0} or {1}".format(_IEXTEN, _TEXTEN), self.name)
 # Normalize
 rawpath = _normpath(subdir, path)
 # Only include once
 relpath = '/' + '/'.join(rawpath)
 if relpath in self.included:
 npath = os.path.join(self.base, *rawpath)
 nsubdir = rawpath[:-1]
 try:
 tf = TemplateFile(npath)
 except OSError as e:
-raise IncludeError(self.name, str(e)) from e
+raise IncludeError(str(e), self.name) from e
 try:
-th = TemplateHeader(tf.headers)
+th = TemplateHeader(tf.header)
 except TemplateHeaderError as e:
-raise IncludeError(npath, str(e)) from e
+raise IncludeError(str(e), npath) from e
 # Reject unsupported crap (included files can only #include)
 for i in dir(th):
 if i.startswith('_') or i == 'include':
 continue
 v = getattr(th, i)
 if callable(v):
 continue
-if v is not None and v is not False:
+if v is not None and v != False:
 raise IncludeError(npath, "unsupported #{0}".format(i))
 # Inclusion is recursive...
 nested = _Includer(self.base, nsubdir, relpath,
 included=self.included, encoding=self.encoding)
-return nested.render(th.includes, tf.body)
+return nested.render(th.include, tf.body)
 # R o u t e s
 #
 # Represents a route in TinCan. Our launcher creates these on-the-fly based
 # on the files it finds.
 def __call__(self, e):
 bottle.request.environ[_FTYPE] = True
 try:
 obj = self._class(bottle.request, e)
 obj.handle()
-return self._template.render(obj.export()).lstrip('\n')
+return self._template.render(obj.export())
 except bottle.HTTPResponse as e:
 return e
 except Exception as e:
 traceback.print_exc()
 # Bottle doesn't allow error handlers to themselves cause
 self._origin = self._urlpath
 self._subdir = subdir
 self._seen = set()
 self._tclass = launcher.tclass
 self._app = launcher.app
+self._save_includes = launcher.debug
 def launch(self):
 """
 Launch a single page.
 """
 raise TinCanError("{0}: #python files must end in {1}".format(self._urlpath, _PEXTEN))
 self._python = self._header.python
 self._python_specified = True
 # Obtain a class object by importing and introspecting a module.
 self._getclass()
-# Build body object (#template)
+# Build body object (#template) and process #includes.
 if self._header.template is not None:
 if not self._header.template.endswith(_TEXTEN):
 raise TinCanError("{0}: #template files must end in {1}".format(self._urlpath, _TEXTEN))
 try:
 rawpath = self._splitpath(self._header.template)
 tsubdir = rawpath[:-1]
+tname = rawpath[-1]
 tpath = os.path.normpath(os.path.join(self._fsroot, *rawpath))
 turlpath = '/' + self._urljoin(rawpath)
 tfile = TemplateFile(tpath)
-thead = TemplateHeader(tpath.header)
+thead = TemplateHeader(tfile.header)
 except (OSError, TemplateHeaderError) as e:
 raise TinCanError("{0}: invalid #template: {1!s}".format(self._urlpath, e)) from e
 except IndexError as e:
 raise TinCanError("{0}: invalid #template".format(self._urlpath)) from e
-includer = _Includer(self._fspath, tsubdir, turlpath)
+r = self._getbody(tsubdir, tname, thead.include, tfile.body)
-try:
+self._dumpbody(r, tpath, turlpath)
-self._body = self._tclass(source=includer.render(thead.include, tfile.body))
-except IncludeError as e:
-raise TinCanError("{0}: #include error: {1!s}".format(turlpath, e)) from e
 else:
-includer = _Includer(self._fspath, self._subdir, self._urlpath)
+r = self._getbody(self._subdir, self._name+_TEXTEN,
-try:
+self._header.include, self._template.body)
-self._body = self._tclass(
+self._dumpbody(r, self._fspath, self._urlpath)
-source=includer.render(self._header.include, self._template.body))
-except IncludeError as e:
-raise TinCanError("{0}: #include error: {1!s}".format(self._urlpath, e)) from e
-self._body.prepare()
 # If this is an #errors page, register it as such.
 if oheader.errors is not None:
 self._mkerror(oheader.errors)
 return  # this implies #hidden
 # Get #methods for this route
 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 _getbody(self, subdir, name, include, body):
+includer = _Includer(self._fsroot, subdir, name)
+try:
+rendered = includer.render(include, body)
+except IncludeError as e:
+raise TinCanError(str(e)) from e
+try:
+self._body = self._tclass(source=rendered)
+self._body.prepare()
+except Exception as e:
+raise TinCanError("{0}: template error: {1!s}".format(urlpath, e)) from e
+return rendered
+def _dumpbody(self, rendered, based_on, logname):
+if self._save_includes:
+try:
+with open(based_on + 'i', w) as fp:
+fp.write(rendered)
+except OSError as e:
+raise TinCanError("{0}: {1!s}".format(logname, e)) from e
 def _splitpath(self, unsplit):
 return _normpath(self._subdir, unsplit)
 def _mkerror(self, rerrors):
 """
 target = None
 try:
 obj = self._class(bottle.request, bottle.response)
 obj.handle()
-return self._body.render(obj.export()).lstrip('\n')
+return self._body.render(obj.export())
 except ForwardException as fwd:
 target = fwd.target
 except bottle.HTTPResponse as e:
 return e
 except Exception as e:
 def _logger(message):
 sys.stderr.write(message)
 sys.stderr.write('\n')
-def launch(fsroot=None, urlroot='/', tclass=ChameleonTemplate, logger=_logger):
+def launch(fsroot=None, urlroot='/', tclass=ChameleonTemplate, logger=_logger, debug=False):
 """
 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()
 launcher = _Launcher(fsroot, urlroot, tclass, logger)
-# launcher.debug = True
+launcher.debug = debug
 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 @ 25:e93e5e746cc5 draft header-includes