tincan: tincan.py comparison

comparison tincan.py @ 35:41da0b3d2156 draft header-includes

Rename #include to #load (more descriptive).

author	David Barts <n5jrn@me.com>
date	Tue, 28 May 2019 15:49:59 -0700
parents	0fb455b46e5f
children	4ed261056057

comparison

equal deleted inserted replaced

-:0fb455b46e5f
+:41da0b3d2156
 self.line = line
 def __str__(self):
 return "line {0}: {1}".format(self.line, self.message)
-class IncludeError(TinCanException):
+class LoadError(TinCanException):
 """
-Raised when we run into problems #include'ing something, usually
+Raised when we run into problems #load'ing something, usually
 because it doesn't exist.
 """
 def __init__(self, message, source):
 super().__init__(message, source)
 self.message = message
 self.source = source
 def __str__(self):
-return "{0}: #include error: {1}".format(self.source, self.message)
+return "{0}: #load 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
 """
 Parses and represents a set of header lines.
 """
 _NAMES = [ "errors", "forward", "methods", "python", "template" ]
 _FNAMES = [ "hidden" ]
-_ANAMES = [ "include" ]
+_ANAMES = [ "load" ]
 def __init__(self, string):
 # Initialize our state
 for i in self._NAMES:
 setattr(self, i, None)
 else:
 setattr(self, name, param)
 # C h a m e l e o n
 #
-# Support for Chameleon templates (the kind TinCan uses by default).
+# Support for Chameleon templates (the kind TinCan uses).
 class ChameleonTemplate(bottle.BaseTemplate):
 def prepare(self, **options):
 from chameleon import PageTemplate, PageTemplateFile
 if self.source:
 self.error = err
 # I n c l u s i o n
 #
 # Most processing is in the TinCanRoute class; this just interprets and
-# represents arguments to the #include header directive.
+# represents arguments to the #load header directive.
-class _IncludedFile(object):
+class _LoadedFile(object):
 def __init__(self, raw):
 if raw.startswith('<') and raw.endswith('>'):
 raw = raw[1:-1]
 self.in_lib = True
 else:
 raise ValueError("empty file name")
 if not self.fname.endswith(_IEXTEN):
 raise ValueError("file does not end in {0}".format(_IEXTEN))
 # Using a cache is likely to help efficiency a lot, since many pages
-# will typically #include the same standard stuff.
+# will typically #load the same standard stuff.
 _tcache = {}
 def _get_template(name, direct):
 aname = os.path.abspath(os.path.join(direct, name))
 if aname not in _tcache:
 tmpl = ChameleonTemplate(name=name, lookup=[direct])
 A route to an error page. These don't get routes created for them,
 and are only reached if an error routes them there. Unless you create
 custom code-behind, only two variables are available to your template:
 request (bottle.Request) and error (bottle.HTTPError).
 """
-def __init__(self, template, includes, klass):
+def __init__(self, template, loads, klass):
 self._template = template
 self._template.prepare()
-self._includes = includes
+self._loads = loads
 self._class = klass
 def __call__(self, e):
 bottle.request.environ[_FTYPE] = True
 try:
 obj = self._class(bottle.request, e)
 obj.handle()
-tvars = self._includes.copy()
+tvars = self._loads.copy()
 tvars.update(obj.export())
 return self._template.render(tvars)
 except bottle.HTTPResponse as e:
 return e
 except Exception as e:
 self._urlpath = self._urljoin(launcher.urlroot, *subdir, name + _TEXTEN)
 self._origin = self._urlpath
 self._subdir = subdir
 self._seen = set()
 self._app = launcher.app
-self._save_includes = launcher.debug
+self._save_loads = 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) and obtain #includes.
+# Build body object (#template) and obtain #loads.
 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:
 rtpath = self._splitpath(self._header.template)
 raise TinCanError("{0}: invalid #template".format(self._urlpath)) from e
 self._body = ChameleonTemplate(source=tfile.body)
 else:
 self._body = ChameleonTemplate(source=self._template.body)
 self._body.prepare()
-# Process includes
+# Process loads
-self._includes = {}
+self._loads = {}
-for include in self._header.include:
+for load in self._header.load:
 try:
-include = _IncludedFile(include)
+load = _LoadedFile(load)
 except ValueError as e:
-raise TinCanError("{0}: bad #include: {1!s}".format(self._urlpath, e)) from e
+raise TinCanError("{0}: bad #load: {1!s}".format(self._urlpath, e)) from e
-if include.in_lib:
+if load.in_lib:
 fdir = os.path.join(self._fsroot, _WINF, "tlib")
 else:
 fdir = os.path.join(self._fsroot, *self._subdir)
 try:
-tmpl = _get_template(include.fname, fdir)
+tmpl = _get_template(load.fname, fdir)
 except Exception as e:
-raise TinCanError("{0}: bad #include: {1!s}".format(self._urlpath, e)) from e
+raise TinCanError("{0}: bad #load: {1!s}".format(self._urlpath, e)) from e
-self._includes[include.vname] = tmpl.tpl
+self._loads[load.vname] = tmpl.tpl
 # 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
 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(ChameleonTemplate(source=self._template.body),
-self._includes, self._class)
+self._loads, 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
 """
 target = None
 try:
 obj = self._class(bottle.request, bottle.response)
 obj.handle()
-tvars = self._includes.copy()
+tvars = self._loads.copy()
 tvars.update(obj.export())
 return self._body.render(tvars)
 except ForwardException as fwd:
 target = fwd.target
 except bottle.HTTPResponse as e:

Mercurial > cgi-bin > hgweb.cgi > tincan

comparison tincan.py @ 35:41da0b3d2156 draft header-includes