Issue 2936 - Support syntax for duplicate translatable strings

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 99 matching lines @@
 
 class Converter:
   whitelist = {"a", "em", "strong", "code", "span"}
   missing_translations = 0
   total_translations = 0
 
   def __init__(self, params, key="pagedata"):
     self._params = params
     self._key = key
     self._attribute_parser = AttributeParser(self.whitelist)
+    self._seen_defaults  = {}
 
     # Read in any parameters specified at the beginning of the file
     lines = params[key].splitlines(True)
     while lines and re.search(r"^\s*[\w\-]+\s*=", lines[0]):
       name, value = lines.pop(0).split("=", 1)
       params[name.strip()] = value.strip()
     params[key] = "".join(lines)
 
   def localize_string(self, page, name, default, comment, localedata, escapes):
     def escape(s):
       return re.sub(r".",
         lambda match: escapes.get(match.group(0), match.group(0)),
         s, flags=re.S)
     def re_escape(s):
       return re.escape(escape(s))
 
+    # Handle duplicated strings
+    if default:
+      self._seen_defaults[(page, name)] = (default, comment)
+    else:
+      try:
+        default, comment = self._seen_defaults[(page, name)]
+      except KeyError:
+        raise Exception("Text not yet defined for string %s on page %s" %
+                        (name, page))
+
     # Extract tag attributes from default string
     default, saved_attributes, fixed_strings = self._attribute_parser.parse(default, self._params["page"])
 
     # Get translation
     locale = self._params["locale"]
     if locale == self._params["defaultlocale"]:
       result = default
     elif name in localedata:
       result = localedata[name].strip()
     else:
@@ skipping 36 matching lines @@
       result = re.sub(
         r"%s([^<>]*?)%s" % (re_escape("<%s>" % tag), re_escape("</%s>" % tag)),
         r"<%s>\1</%s>" % (tag, tag),
         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()
-      default = to_html(default).strip()
-
+      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"(?:(?:\[(.*?)\])?" # Optional comment
+        r"\s+"
+        r"((?:(?!{{).|" # Translatable text
+          r"{{(?:(?!}}).)*}}" # Nested translation
+        r")*?)"
+      r")?"
       r"}}",
       lookup_string,
       text,
       flags=re.S
     )
 
   def process_links(self, text):
     def process_link(match):
       pre, attr, url, post = match.groups()
       url = jinja2.Markup(url).unescape()
@@ skipping 190 matching lines @@
         stack.pop()
       stack[-1]["subitems"].append(item)
       stack.append(item)
     return structured
 
 converters = {
   "html": RawConverter,
   "md": MarkdownConverter,
   "tmpl": TemplateConverter,
 }