Issue 2139 - Allow nested translations for tag attributes.

cms/converters.py

Index: cms/converters.py
diff --git a/cms/converters.py b/cms/converters.py
index b853f78c4eb0625671a797a6640006c772929ad6..86c934b7fe70d7454bdf7f0cf3af76e3b8527a90 100644
--- a/cms/converters.py
+++ b/cms/converters.py
@@ -145,6 +145,7 @@ class Converter:
     # Insert attributes
     result = escape(result)
     def stringify_attribute((name, value)):
+      value = self.insert_localized_strings(value, escapes)
       if name == "href":
         link_locale, link = self._params["source"].resolve_link(value, locale)
         if link:
@@ -168,20 +169,40 @@ class Converter:
     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()
-
-      # Note: We currently ignore the comment, it is only relevant when
-      # generating the master translation.
-      return self.localize_string(name, default, self._params["localedata"], escapes)
-
-    return re.sub(
-      r"\{\{\s*([\w\-]+)(?:\[(.*?)\])?\s+(.*?)\}\}",
-      lookup_string,
-      text,
-      flags=re.S
-    )
+    # Find the positions for the top-level translatable strings
+    level = 0
+    start = None
+    positions = []
+    for m in re.finditer(r"(\{\{|\}\})", text):
+      if m.group(0) == "{{":
+        if level == 0:
+          start = m.start()
+        level += 1
+      else:
+        level -= 1
+        if level == 0:
+          positions.append((start, m.end()))
+
+    # Replace each string with it's translation
+    parts = []
+    last_end = 0
+    for start, end in positions:
+      # Append any text before this tag since the last one
+      parts.append(text[last_end:start])
+      # Append our localized string
+      name, comment, default = re.match(
+        r"\{\{\s*([\w\-]+)(?:\[(.*?)\])?\s+(.*)\}\}",

[Wladimir Palant, 2015/04/16 21:01:13]

Only one nesting level is actually allowed here. So instead of finding positions
above we can use a more complicated regexp:

  r"\{\{\s*"
  r"([\w\-]+)"      # String ID
  r"(?:\[(.*?)\])?" # Optional comment
  r"\s+"
  r"(?:[^\{]|\{(?!{)|\{\{.*\}\})*?"  # Translatable text (could contain other
translatable strings)
  r"\}\}"

Yes, you can split the regexp into multiple lines like that.

[kzar, 2015/04/21 11:28:57]

With a couple of tweaks I managed to get your regexp matching how we want:

r"\{\{\s*"
r"([\w\-]+)" # String ID
r"(?:\[(.*?)\])?" # Optional comment
r"\s+"
r"((?:[^\{]|\{(?!\{)|\{\{.*\}\})*?)" # Translatable text
r"\}\}"

Problem is when that regexp is used with the re.S (dot matches all) flag it runs
forever (or a long time at least) maxing out one of my CPU cores. Without the
flag it works fine, but I guess we want to support multi-line default
translation strings.

Any ideas what's happening?

[kzar, 2015/04/21 14:44:53]

OK I made another change to the regexp to hopefully avoid exponential
complexity. For the contents of nested tags I replaced the .* with
(?:[^\}]|\}(?!\}))*? .

As we know there can only be one level of nesting I ensure "}}" does not appear
inside the child tag. I think that avoids backticking crazily each time the
final "}}" of the regexp doesn't match.

The regexp is getting pretty huge though now, I worry it's less readable than my
old solution.

+        text[start:end],
+        flags=re.S
+      ).groups()
+      parts.append(self.localize_string(
+        name,
+        to_html(default).strip(),
+        self._params["localedata"],
+        escapes
+      ))
+      last_end = end
+    return "".join(parts) + text[last_end:]
 
   def process_links(self, text):
     def process_link(match):