Issue 3084 - [cms] Show full tracebacks for exceptions passing template code

cms/sources.py

 # coding: utf-8
 
 # This file is part of the Adblock Plus web scripts,
 # Copyright (C) 2006-2015 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 
-import codecs
+import io
 import collections
 import ConfigParser
 import json
 import os
 from StringIO import StringIO
 import subprocess
 import urlparse
 import zipfile
 import logging
-
-import jinja2
-
-TEMPLATE_SUFFIX = '.tmpl'
-
-class SuffixTemplateLoader(jinja2.BaseLoader):
-  def __init__(self, loader, suffix=TEMPLATE_SUFFIX):
-    self.loader = loader
-    self.suffix = suffix
-
-  def get_source(self, environment, template):
-    return self.loader.get_source(environment, template + self.suffix)
 
 class Source:
   def resolve_link(self, url, locale):
     parsed = urlparse.urlparse(url)
     page = parsed.path
     if parsed.scheme != "" or page.startswith("/") or page.startswith("."):
       # Not a page link
       return None, None
 
     if page == "" and url != "":
@@ skipping 18 matching lines @@
       logging.warning("Link to %s cannot be resolved", page)
 
     parts = page.split("/")
     if parts[-1] == default_page:
       page = "/".join(parts[:-1])
 
     path = "/%s/%s" % (locale, page)
     return locale, urlparse.urlunparse(parsed[0:2] + (path,) + parsed[3:])
 
   def read_config(self):
-    configdata = self.read_file("settings.ini")
+    configdata = self.read_file("settings.ini")[0]
     config = ConfigParser.SafeConfigParser()
     config.readfp(StringIO(configdata))
     return config
 
-  def import_symbol(self, filename, symbol):
-    code = self.read_file(filename)
+  def exec_file(self, filename):
+    source, filename = self.read_file(filename)
+    code = compile(source, filename, "exec")
     namespace = {}
     exec code in namespace
-
-    try:
-      return namespace[symbol]
-    except KeyError:
-      raise Exception("Expected symbol %s not found in %s" % (symbol, filename))
+    return namespace
 
   #
   # Page helpers
   #
 
   @staticmethod
   def page_filename(page, format):
     return "pages/%s.%s" % (page, format)
 
   def list_pages(self):
@@ skipping 27 matching lines @@
     default_locale = self.read_config().get("general", "defaultlocale")
     return filter(
       lambda f: os.path.splitext(f)[1].lower() != ".json",
       self.list_files("locales/%s" % default_locale)
     )
 
   def has_localizable_file(self, locale, filename):
     return self.has_file(self.localizable_file_filename(locale, filename))
 
   def read_localizable_file(self, locale, filename):
-    return self.read_file(self.localizable_file_filename(locale, filename), binary=True)
+    return self.read_file(self.localizable_file_filename(locale, filename), binary=True)[0]
 
   #
   # Static file helpers
   #
 
   @staticmethod
   def static_filename(filename):
     return "static/%s" % filename
 
   def list_static(self):
     return self.list_files("static")
 
   def has_static(self, filename):
     return self.has_file(self.static_filename(filename))
 
   def read_static(self, filename):
-    return self.read_file(self.static_filename(filename), binary=True)
+    return self.read_file(self.static_filename(filename), binary=True)[0]
 
   #
   # Locale helpers
   #
 
   @classmethod
   def locale_filename(cls, locale, page):
     return cls.localizable_file_filename(locale, page + ".json")
 
   def list_locales(self):
@@ skipping 12 matching lines @@
       pass
     return self.has_file(self.locale_filename(locale, page))
 
   def read_locale(self, locale, page):
     default_locale = self.read_config().get("general", "defaultlocale")
     result = collections.OrderedDict()
     if locale != default_locale:
       result.update(self.read_locale(default_locale, page))
 
     if self.has_locale(locale, page):
-      filedata = self.read_file(self.locale_filename(locale, page))
+      filedata = self.read_file(self.locale_filename(locale, page))[0]
       localedata = json.loads(filedata)
       for key, value in localedata.iteritems():
         result[key] = value["message"]
 
     return result
 
   #
   # Template helpers
   #
 
   @staticmethod
   def template_filename(template):
-    return "templates/%s%s" % (template, TEMPLATE_SUFFIX)
+    return "templates/%s.tmpl" % template
 
   def read_template(self, template):
     return self.read_file(self.template_filename(template))
-
-  def get_template_loader(self):
-    return SuffixTemplateLoader(jinja2.FunctionLoader(self.read_file))
 
   #
   # Include helpers
   #
 
   @staticmethod
   def include_filename(include, format):
     return "includes/%s.%s" % (include, format)
 
   def has_include(self, include, format):
@@ skipping 25 matching lines @@
     self._archive.close()
 
   def has_file(self, filename):
     try:
       self._archive.getinfo("./%s" % filename)
     except KeyError:
       return False
     return True
 
   def read_file(self, filename, binary=False):
-    result = self._archive.read("./%s" % filename)
+    data = self._archive.read("./%s" % filename)
     if not binary:
-      result = result.decode("utf-8")
-    return result
+      data = data.decode("utf-8")
+    return (data, "%s!%s" % (self._name, filename))
 
   def list_files(self, subdir):
     prefix = "./%s/" % subdir
     for filename in self._archive.namelist():
       if filename.startswith(prefix):
         yield filename[len(prefix):]
 
   if os.name == "posix":
     def get_cache_dir(self):
       return "/var/cache/" + self._name
@@ skipping 11 matching lines @@
   def close(self):
     pass
 
   def get_path(self, filename):
     return os.path.join(self._dir, *filename.split("/"))
 
   def has_file(self, filename):
     return os.path.isfile(self.get_path(filename))
 
   def read_file(self, filename, binary=False):
-    encoding = None if binary else "utf-8"
-    with codecs.open(self.get_path(filename), "rb", encoding=encoding) as handle:
-      return handle.read()
+    path = self.get_path(filename)
+
+    if binary:
+      file = open(path, "rb")
+    else:
+      file = io.open(path, "r", encoding="utf-8")
+
+    with file:
+      return (file.read(), path)
 
   def list_files(self, subdir):
     result = []
     def do_list(dir, relpath):
       try:
         files = os.listdir(dir)
       except OSError:
         return
 
       for filename in files:
         path = os.path.join(dir, filename)
         if os.path.isfile(path):
           result.append(relpath + filename)
         elif os.path.isdir(path):
           do_list(path, relpath + filename + "/")
     do_list(self.get_path(subdir), "")
     return result
 
   def get_cache_dir(self):
     return os.path.join(self._dir, "cache")
-
-  def get_template_loader(self):
-    return SuffixTemplateLoader(jinja2.FileSystemLoader(self._dir))

[Sebastian Noack, 2015/09/15 17:48:36]

We need a loader that is aware of the filename for templates loaded via {%
include %} and {% import %}. Theoretically we could also use
Environment.get_template() now, but this doesn't seem to workout with the
architecture of the CMS .