Issue 4217 - Fix Prefix Regression Due To Mercurial Version Behavior Change

cms/sources.py

 # This file is part of the Adblock Plus web scripts,
 # Copyright (C) 2006-2016 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 40 matching lines @@
         elif self.has_page(alternative_page):
             if not self.has_locale(locale, alternative_page):
                 locale = default_locale
         else:
             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)
+        path = '/{}/{}'.format(locale, page)

[Sebastian Noack, 2016/07/01 11:18:47]

Replacing legacy string formatting (using the % operator) with the format()
method across the file is an unrelated change and should rather go into a
separate review and commit.

         return locale, urlparse.urlunparse(parsed[0:2] + (path,) + parsed[3:])
 
     def read_config(self):
         configdata = self.read_file('settings.ini')[0]
         config = ConfigParser.SafeConfigParser()
         config.readfp(StringIO(configdata))
         return config
 
     def exec_file(self, filename):
         source, filename = self.read_file(filename)
         code = compile(source, filename, 'exec')
         namespace = {}
         exec code in namespace
         return namespace
 
     #
     # Page helpers
     #
 
     @staticmethod
     def page_filename(page, format):
-        return 'pages/%s.%s' % (page, format)
+        return 'pages/{}.{}'.format(page, format)
 
     def list_pages(self):
         for filename in self.list_files('pages'):
             root, ext = os.path.splitext(filename)
             format = ext[1:].lower()
             yield root, format
 
     def has_page(self, page, format=None):
         if format is None:
             from cms.converters import converters
             return any(
                 self.has_page(page, format)
                 for format in converters.iterkeys()
             )
         else:
             return self.has_file(self.page_filename(page, format))
 
     def read_page(self, page, format):
         return self.read_file(self.page_filename(page, format))
 
     #
     # Localizable files helpers
     #
 
     @staticmethod
     def localizable_file_filename(locale, filename):
-        return 'locales/%s/%s' % (locale, filename)
+        return 'locales/{}/{}'.format(locale, filename)
 
     def list_localizable_files(self):
         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)
+            self.list_files('locales/{}'.format(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)[0]
 
     #
     # Static file helpers
     #
 
     @staticmethod
     def static_filename(filename):
-        return 'static/%s' % filename
+        return 'static/{}'.format(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)[0]
 
@@ skipping 34 matching lines @@
                 result[key] = value['message']
 
         return result
 
     #
     # Template helpers
     #
 
     @staticmethod
     def template_filename(template):
-        return 'templates/%s.tmpl' % template
+        return 'templates/{}.tmpl'.format(template)
 
     def read_template(self, template):
         return self.read_file(self.template_filename(template))
 
     #
     # Include helpers
     #
 
     @staticmethod
     def include_filename(include, format):
-        return 'includes/%s.%s' % (include, format)
+        return 'includes/{}.{}'.format(include, format)
 
     def has_include(self, include, format):
         return self.has_file(self.include_filename(include, format))
 
     def read_include(self, include, format):
         return self.read_file(self.include_filename(include, format))
 
 
 class MercurialSource(Source):
     def __init__(self, repo):
         command = ['hg', '-R', repo, 'archive', '-r', 'default',
-                   '-t', 'uzip', '-p', '.', '-']
+                   '-t', 'uzip', '-p', 'root', '-']
         data = subprocess.check_output(command)
         self._archive = zipfile.ZipFile(StringIO(data), mode='r')
 
         command = ['hg', '-R', repo, 'id', '-n', '-r', 'default']
         self.version = subprocess.check_output(command).strip()
 
         self._name = os.path.basename(repo.rstrip(os.path.sep))
 
     def __enter__(self):
         return self
 
     def __exit__(self, type, value, traceback):
         self.close()
         return False
 
     def close(self):
         self._archive.close()
 
     def has_file(self, filename):
         try:
-            self._archive.getinfo('./%s' % filename)
+            self._archive.getinfo('root/{}'.format(filename))
         except KeyError:
             return False
         return True
 
     def read_file(self, filename, binary=False):
-        data = self._archive.read('./%s' % filename)
+        data = self._archive.read('root/{}'.format(filename))
         if not binary:
             data = data.decode('utf-8')
-        return (data, '%s!%s' % (self._name, filename))
+        return (data, '{}!{}'.format(self._name, filename))
 
     def list_files(self, subdir):
-        prefix = './%s/' % subdir
+        prefix = 'root/{}/'.format(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
 
 
 class FileSource(Source):
@@ skipping 39 matching lines @@
                 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')