Issue 2180 - [cms] Add support for custom Jinja2 functions

cms/converters.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,
@@ skipping 265 matching lines @@
 
         path = "%s/%s" % (dirname, filename)
         code = self._params["source"].read_file(path)
         module = imp.new_module(root.replace("/", "."))
         exec code in module.__dict__
 
         name = os.path.basename(root)
         if not hasattr(module, name):
           raise Exception("Expected symbol %s not found in %s file %s" % (name, dirname, filename))
         dictionary[name] = getattr(module, name)
-        if hasattr(dictionary[name], "__call__"):

[Sebastian Noack, 2015/03/20 16:10:54]

You might want to use the callable() built-in function instead. But how does it
come that this hack is necessary? 

[Wladimir Palant, 2015/03/20 16:21:12]

A function doesn't usually have a reference to its module, and the modules we
load here aren't being added to any global table. So while the functions
themselves aren't garbage collected, the module might - and then the function
will suddenly be unable to access variables or imports from its module.

[Sebastian Noack, 2015/03/20 16:26:54]

Yeah, this actually make sense, since we create the module, as opposed to
importing it where a reference ends up in sys.modules. And since global
variables aren't bound to the closure of the function they get lost if there
isn't a reference to the module anymore. But that is certainly worth a more
verbose comment.

[Wladimir Palant, 2015/03/20 16:42:50]

Done.

-          dictionary[name].module_ref = module  # Prevent garbage collection
+
+        # HACK: The module we created here can be garbage collected because it
+        # isn't added to sys.modules. If a function is called and its module is
+        # gone it might cause weird errors (imports and module variables
+        # unavailable). We avoid this situation by explicitly referencing the
+        # module from the function so they can only be garbage collected
+        # together.
+        if callable(dictionary[name]):
+          dictionary[name].module_ref = module
 
     self._env = jinja2.Environment(loader=self._SourceLoader(self._params["source"]), autoescape=True)
     self._env.filters.update(filters)
     self._env.globals.update(globals)
 
   def get_html(self, source):
     template = self._env.from_string(source)
     module = template.make_module(self._params)
     for key, value in module.__dict__.iteritems():
       if not key.startswith("_"):
@@ skipping 40 matching lines @@
         stack.pop()
       stack[-1]["subitems"].append(item)
       stack.append(item)
     return structured
 
 converters = {
   "html": RawConverter,
   "md": MarkdownConverter,
   "tmpl": TemplateConverter,
 }