Allow substitution of messages as variables in other messages.

grit/node/misc.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 '''Miscellaneous node types.
 '''
 
 import os.path
 import re
 import sys
 
 from grit.node import base
 from grit.node import message
 
 from grit import exception
 from grit import constants
 from grit import util
 
 import grit.format.rc_header
 
 
+# RTL languages
+# TODO(jennyz): remove this fixed set of RTL language array
+# now that generic expand_variable code exists.
+_RTL_LANGS = (
+    'ar',  # Arabic
+    'fa',  # Farsi
+    'iw',  # Hebrew
+    'ks',  # Kashmiri
+    'ku',  # Kurdish
+    'ps',  # Pashto
+    'ur',  # Urdu
+    'yi',  # Yiddish
+)
+
+
 def _ReadFirstIdsFromFile(filename, defines):
   '''Read the starting resource id values from |filename|.  We also
   expand variables of the form <(FOO) based on defines passed in on
   the command line.
 
   Returns a tuple, the absolute path of SRCDIR followed by the
   first_ids dictionary.
   '''
   first_ids_dict = eval(open(filename).read())
   src_root_dir = os.path.abspath(os.path.join(os.path.dirname(filename),
@@ skipping 48 matching lines @@
 
   def MandatoryAttributes(self):
     return ['expr']
 
   def IsConditionSatisfied(self):
     '''Returns true if and only if the Python expression stored in attribute
     'expr' evaluates to true.
     '''
     return self.EvaluateCondition(self.attrs['expr'])
 
+  def SatisfiesOutputCondition(self):
+    '''Returns true if its condition is satisfied, including on ancestors.'''
+    if not self.IsConditionSatisfied():
+      return False
+    else:
+      return base.Node.SatisfiesOutputCondition(self)
+
 
 class ReleaseNode(base.Node):
   '''The <release> element.'''
 
   def _IsValidChild(self, child):
     from grit.node import empty
     return isinstance(child, (empty.IncludesNode, empty.MessagesNode,
                               empty.StructuresNode, empty.IdentifiersNode))
 
   def _IsValidAttribute(self, name, value):
@@ skipping 19 matching lines @@
     else:
       return super(type(self), self).ItemFormatter(t)
 
 class GritNode(base.Node):
   '''The <grit> root element.'''
 
   def __init__(self):
     base.Node.__init__(self)
     self.output_language = ''
     self.defines = {}
+    self.substituter = util.Substituter()
 
   def _IsValidChild(self, child):
     from grit.node import empty
     return isinstance(child, (ReleaseNode, empty.TranslationsNode,
                               empty.OutputsNode))
 
   def _IsValidAttribute(self, name, value):
     if name not in ['base_dir', 'first_ids_file', 'source_lang_id',
                     'latest_public_release', 'current_release',
-                    'enc_check', 'tc_project']:
+                    'enc_check', 'tc_project', 'grit_version']:
       return False
     if name in ['latest_public_release', 'current_release'] and value.strip(
       '0123456789') != '':
       return False
     return True
 
   def MandatoryAttributes(self):
     return ['latest_public_release', 'current_release']
 
   def DefaultAttributes(self):
     return {
       'base_dir' : '.',
       'first_ids_file': '',
+      'grit_version': 1,
       'source_lang_id' : 'en',
       'enc_check' : constants.ENCODING_CHECK,
       'tc_project' : 'NEED_TO_SET_tc_project_ATTRIBUTE',
     }
 
   def EndParsing(self):
     base.Node.EndParsing(self)
     if (int(self.attrs['latest_public_release'])
         > int(self.attrs['current_release'])):
       raise exception.Parsing('latest_public_release cannot have a greater '
@@ skipping 121 matching lines @@
     '''Returns the list of <output> nodes that are descendants of this node's
     <outputs> child and are not enclosed by unsatisfied <if> conditionals.
     '''
     for child in self.children:
       if child.name == 'outputs':
         output_files = []
         self._CollectOutputFiles(child.children, output_files)
         return output_files
     raise exception.MissingElement()
 
+  def GetSubstitutionMessages(self):
+    '''Returns the list of <message sub_variable="true"> nodes.'''
+    msg_nodes = self.GetChildrenOfType(message.MessageNode)
+    return [n for n in msg_nodes if
+            n.attrs['sub_variable'] == 'true' and n.SatisfiesOutputCondition()]
+
   def ItemFormatter(self, t):
     if t == 'rc_header':
       from grit.format import rc_header  # import here to avoid circular dep
       return rc_header.TopLevel()
     elif t in ['rc_all', 'rc_translateable', 'rc_nontranslateable']:
       from grit.format import rc  # avoid circular dep
       return rc.TopLevel()
     elif t == 'c_format':
       from grit.format import c_format
       return c_format.TopLevel()
     elif t == 'resource_map_header':
       from grit.format import resource_map
       return resource_map.HeaderTopLevel()
     elif t in ('resource_map_source', 'resource_file_map_source'):
       from grit.format import resource_map
       return resource_map.SourceTopLevel()
     elif t == 'js_map_format':
       from grit.format import js_map_format
       return js_map_format.TopLevel()
     elif t in ('adm', 'plist', 'plist_strings', 'admx', 'adml', 'doc', 'json',
         'reg'):
       from grit.format.policy_templates import template_formatter
       return template_formatter.TemplateFormatter(t)
     else:
       return super(type(self), self).ItemFormatter(t)
 
   def SetOutputContext(self, output_language, defines):
+    '''Set the output context: language and defines. Prepares substitutions.
+
+    The substitutions are reset every time the OutputContext is changed.
+    They include messages designated as variables, and language codes for html
+    and rc files.
+
+    Args:
+      output_language: a two-letter language code (eg: 'en', 'ar'...)
+      defines: a map of names to values (strings or booleans.)
+    '''
+    output_language = output_language or self.GetSourceLanguage()
     self.output_language = output_language
     self.defines = defines
+    self.substituter.AddMessages(self.GetSubstitutionMessages(),
+                                 output_language)
+    if output_language in _RTL_LANGS:
+      direction = 'dir="RTL"'
+    else:
+      direction = 'dir="LTR"'
+    self.substituter.AddSubstitutions({
+        'GRITLANGCODE': output_language,
+        'GRITDIR': direction,
+    })
+    from grit.format import rc  # avoid circular dep
+    rc.RcSubstitutions(self.substituter, output_language)
 
   def SetDefines(self, defines):
     self.defines = defines
 
   def AssignFirstIds(self, filename_or_stream, defines):
     '''Assign first ids to each grouping node based on values from the
     first_ids file (if specified on the <grit> node).
     '''
     # If the input is a stream, then we're probably in a unit test and
     # should skip this step.
@@ skipping 30 matching lines @@
                  'update that file.' % (first_ids_filename, filename))
           print '-' * 78
           raise e
 
         try:
           node.attrs['first_id'] = str(id_list.pop(0))
         except IndexError, e:
           raise Exception('Please update %s and add a first id for %s (%s).'
                           % (first_ids_filename, filename, node.name))
 
+  def RunGatherers(self, recursive=0, debug=False):
+    '''Gathers information for the structure nodes, then apply substitutions.
+
+    The substitutions step requires that the OutputContext has been set.
+    Locally, get the Substitution messages
+    and add them to the substituter. Also add substitutions for language codes
+    in the Rc.
+
+    Args:
+      recursive: will call RunGatherers() recursively on all child nodes first.
+      debug: will print information while running gatherers.
+    '''
+    base.Node.RunGatherers(self, recursive, False)
+    assert self.output_language
+    self.SubstituteMessages(self.substituter)
+
 
 class IdentifierNode(base.Node):
   '''A node for specifying identifiers that should appear in the resource
   header file, and be unique amongst all other resource identifiers, but don't
   have any other attributes or reference any resources.
   '''
 
   def MandatoryAttributes(self):
     return ['name']
 
@@ skipping 17 matching lines @@
     by parameters of the same name.
     '''
     node = IdentifierNode()
     node.StartParsing('identifier', parent)
     node.HandleAttribute('name', name)
     node.HandleAttribute('id', id)
     node.HandleAttribute('comment', comment)
     node.EndParsing()
     return node
   Construct = staticmethod(Construct)