Noissue - Adapt best practices for trailing commas (cms)

cms/converters.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 166 matching lines @@
         # Insert fixed strings
         for i, fixed_string in enumerate(fixed_strings, 1):
             result = result.replace('{{{}}}'.format(i), fixed_string)
 
         # Insert attributes
         result = escape(result)
 
         def stringify_attribute(name, value):
             return '{}="{}"'.format(
                 escape(name),
-                escape(self.insert_localized_strings(value, {}))
+                escape(self.insert_localized_strings(value, {})),
             )
 
         for tag in self.whitelist:
             allowed_contents = '(?:[^<>]|{})'.format('|'.join(
                 '<(?:{}[^<>]*?|/{})>'.format(t, t)
                 for t in map(re.escape, self.whitelist - {tag})
             ))
             saved = saved_attributes.get(tag, [])
             for attrs in saved:
                 attrs = [stringify_attribute(*attr) for attr in attrs]
                 result = re.sub(
                     r'{}({}*?){}'.format(re_escape('<{}>'.format(tag)),
                                          allowed_contents,
                                          re_escape('</{}>'.format(tag))),
                     lambda match: r'<{}{}>{}</{}>'.format(
                         tag,
                         ' ' + ' '.join(attrs) if attrs else '',
                         match.group(1),
-                        tag
+                        tag,
                     ),
-                    result, 1, flags=re.S
+                    result, 1, flags=re.S,
                 )
             result = re.sub(
                 r'{}({}*?){}'.format(re_escape('<{}>'.format(tag)),
                                      allowed_contents,
                                      re_escape('</{}>'.format(tag))),
                 r'<{}>\1</{}>'.format(tag, tag),
-                result, flags=re.S
+                result, flags=re.S,
             )
         return result
 
     def insert_localized_strings(self, text, escapes, to_html=lambda s: s):
         def lookup_string(match):
             name, comment, default = match.groups()
             if default:
                 default = to_html(default).strip()
             return self.localize_string(self._params['page'], name, default,
                                         comment, self._params['localedata'],
                                         escapes)
 
         return re.sub(
             r'{{\s*'
             r'([\w\-]+)'  # String ID
             r'(?:(?:\[(.*?)\])?'  # Optional comment
             r'\s+'
             r'((?:(?!{{).|'  # Translatable text
             r'{{(?:(?!}}).)*}}'  # Nested translation
             r')*?)'
             r')?'
             r'}}',
             lookup_string,
             text,
-            flags=re.S
+            flags=re.S,
         )
 
     def process_links(self, text):
         def process_link(match):
             pre, attr, url, post = match.groups()
             url = jinja2.Markup(url).unescape()
 
             locale, new_url = (
                 self._params['source']
                 .resolve_link(url, self._params['locale']))
@@ skipping 33 matching lines @@
                     result = converter()
                     self.missing_translations += converter.missing_translations
                     self.total_translations += converter.total_translations
                     return result
             raise Exception('Failed to resolve include {}'
                             ' on page {}'.format(name, self._params['page']))
 
         return re.sub(
             r'{}\?\s*include\s+([^\s<>"]+)\s*\?{}'.format(
                 self.include_start_regex,
-                self.include_end_regex
+                self.include_end_regex,
             ),
             resolve_include,
-            text
+            text,
         )
 
     def __call__(self):
         result = self.get_html(self._data, self._filename)
         return self.resolve_includes(result)
 
 
 class RawConverter(Converter):
     def get_html(self, source, filename):
         result = self.insert_localized_strings(source, html_escapes)
         result = self.process_links(result)
         return result
 
 
 class MarkdownConverter(Converter):
     include_start_regex = r'(?:{}|{})'.format(
         Converter.include_start_regex,
-        re.escape(jinja2.escape(Converter.include_start_regex))
+        re.escape(jinja2.escape(Converter.include_start_regex)),
     )
     include_end_regex = r'(?:{}|{})'.format(
         Converter.include_end_regex,
-        re.escape(jinja2.escape(Converter.include_end_regex))
+        re.escape(jinja2.escape(Converter.include_end_regex)),
     )
 
     def get_html(self, source, filename):
         def remove_unnecessary_entities(match):
             char = unichr(int(match.group(1)))
             if char in html_escapes:
                 return match.group(0)
             return char
 
         escapes = {}
@@ skipping 85 matching lines @@
             if not key.startswith('_'):
                 self._params[key] = value
 
         result = unicode(module)
         result = self.process_links(result)
         return result
 
     def translate(self, default, name, comment=None):
         return jinja2.Markup(self.localize_string(
             self._params['page'], name, default, comment,
-            self._params['localedata'], html_escapes
+            self._params['localedata'], html_escapes,
         ))
 
     def get_string(self, name, page=None):
         if page is None:
             page = self._params['page']
 
         localedata = self._get_locale_data(page)
         default = localedata[name]
         return jinja2.Markup(self.localize_string(
-            page, name, default, '', localedata, html_escapes
+            page, name, default, '', localedata, html_escapes,
         ))
 
     def has_string(self, name, page=None):
         if page is None:
             page = self._params['page']
 
         localedata = self._get_locale_data(page)
         return name in localedata
 
     def get_page_content(self, page, locale=None):
         if locale is None:
             locale = self._params['locale']
         return utils.get_page_params(self._params['source'], locale, page)
 
     def linkify(self, page, locale=None, **attrs):
         if locale is None:
             locale = self._params['locale']
 
         locale, url = self._params['source'].resolve_link(page, locale)
         return jinja2.Markup('<a{}>'.format(''.join(
             ' {}="{}"'.format(name, jinja2.escape(value)) for name, value in [
                 ('href', url),
-                ('hreflang', locale)
+                ('hreflang', locale),
             ] + attrs.items()
         )))
 
     def get_pages_metadata(self, filters=None):
         if filters is not None and not isinstance(filters, dict):
             raise TypeError('Filters are not a dictionary')
 
         return_data = []
         for page_name, _format in self._params['source'].list_pages():
             data, filename = self._params['source'].read_page(page_name,
@@ skipping 26 matching lines @@
 
     def get_canonical_url(self, page):
         """Return canonical URL for the page (without locale code)"""
         try:
             base_url = self._params['site_url']
         except KeyError:
             raise Exception('You must configure `siteurl` to use'
                             '`get_canonical_url()`')
 
         locale, page_url = self._params['source'].resolve_link(
-            page, self._params['locale']
+            page, self._params['locale'],
         )
         # Remove the locale component that `resolve_link` adds at the
         # beginning.
         page_url = page_url[len(locale) + 1:]
         return urlparse.urljoin(base_url, page_url)
 
     def toclist(self, content):
         toc_re = r'<h(\d)\s[^<>]*\bid="([^<>"]+)"[^<>]*>(.*?)</h\1>'
         flat = []
         for match in re.finditer(toc_re, content, re.S):
@@ skipping 12 matching lines @@
             stack[-1]['subitems'].append(item)
             stack.append(item)
         return structured
 
 
 converters = {
     'html': RawConverter,
     'md': MarkdownConverter,
     'tmpl': TemplateConverter,
 }