Issue 5336 - Allow additional include, page, and template paths using CMS

cms/sources.py

 # This file is part of the Adblock Plus web scripts,
 # Copyright (C) 2006-present 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
@@ skipping 323 matching lines @@
     def has_file(self, filename):
         return any(base.has_file(filename) for base in self._bases)
 
     def read_file(self, filename, binary=False):
         for base in self._bases:
             if base.has_file(filename):
                 return base.read_file(filename, binary)
         raise KeyError('File not found {}'.format(filename))
 
     def list_files(self, subdir):
-        return list({f for base in self._bases
-                     for f in base.list_files(subdir)})
+        return {f for base in self._bases for f in base.list_files(subdir)}
 
 
 def _memoize(func):
     """Cache results of functions calls."""
     memoized = {}
 
     def wrapper(*args):
         try:
             return memoized[args]
         except KeyError:
             return memoized.setdefault(args, func(*args))
     wrapper.cache_clear = memoized.clear
     return wrapper
 
 
-def create_source(path, static=False, revision='default'):
+def create_source(path, cached=False, revision=None):
     """Create a source from path and optional revision.
 
-    `static` flag determines the type of the source that will be created and
-    its caching behavior:
-    - If `static` is `True`, we use version-control-aware `MercurialSource`,
-      pass the revision and cache the results of most used functions.
-    - If `static` is `False` (as is the case with the preview server), we use
-      simpler `FileSource` and don't cache anything to be able to respond to
-      changes on the filesystem.
+    `cached` flag activates caching. This can be used to optimize performance
+    if no changes are expected on the filesystem after the source was created.
+    This is usually the case with static generation (as opposed to dynamic
+    preview).
+
+    If `revision` option is provided, the `path` is assumed to be pointing to a
+    Mercurial repository. In this case the source will return the content of
+    selected revision (using `MercurialSource`) instead of the content of the
+    directory. Note that any local changes will be ignored in this case.
 
     If `settings.ini` in the source contains `[paths]` section with an
     `additional-paths` key that contains the list of additional root folders,
     `MultiSource` will be instantiated and its bases will be the original
     source plus an additional source for each additional root folder.
     `MultiSource` looks up files in its base sources in the order they are
     provided, so the files in the additional folders will only be used if the
     original source doesn't contain that file.
     """
-    if static:
+    if revision is not None:
         source = MercurialSource(path, revision)
     else:
         source = FileSource(path)
 
     config = source.read_config()
     try:
         ap = config.get('paths', 'additional-paths').strip()
         additional_paths = filter(None, ap.split())
-    except ConfigParser.NoSectionError:
+    except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
         additional_paths = []
 
     if additional_paths:
         additional_sources = [
             create_source(os.path.join(path, p))
             for p in additional_paths
         ]
         source = MultiSource([source] + additional_sources)
 
-    if static:
+    if cached:
         for fname in [
             'resolve_link',
             'read_config',
             'read_template',
             'read_locale',
             'read_include',
             'exec_file',
         ]:
             setattr(source, fname, _memoize(getattr(source, fname)))
 
     return source