Allow substitution of messages as variables in other messages.

grit/tool/build.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.
 
 '''The 'grit build' tool along with integration for this tool with the
 SCons build system.
 '''
 
 import filecmp
 import getopt
 import os
 import shutil
 import sys
 import types
 
 from grit import grd_reader
 from grit import util
 from grit.tool import interface
 from grit import shortcuts
 
 
-def ParseDefine(define):
-  '''Parses a define that is either like "NAME" or "NAME=VAL" and
-  returns its components, using True as the default value.  Values of
-  "1" and "0" are transformed to True and False respectively.
-  '''
-  parts = [part.strip() for part in define.split('=')]
-  assert len(parts) >= 1
-  name = parts[0]
-  val = True
-  if len(parts) > 1:
-    val = parts[1]
-  if val == "1": val = True
-  elif val == "0": val = False
-  return (name, val)
-
-
 class RcBuilder(interface.Tool):
   '''A tool that builds RC files and resource header files for compilation.
 
 Usage:  grit build [-o OUTPUTDIR] [-D NAME[=VAL]]*
 
 All output options for this tool are specified in the input file (see
 'grit help' for details on how to specify the input file - it is a global
 option).
 
 Options:
@@ skipping 28 matching lines @@
 
   def Run(self, opts, args):
     self.output_directory = '.'
     first_ids_file = None
     whitelist_filenames = []
     (own_opts, args) = getopt.getopt(args, 'o:D:E:f:w:')
     for (key, val) in own_opts:
       if key == '-o':
         self.output_directory = val
       elif key == '-D':
-        name, val = ParseDefine(val)
+        name, val = util.ParseDefine(val)
         self.defines[name] = val
       elif key == '-E':
         (env_name, env_value) = val.split('=')
         os.environ[env_name] = env_value
       elif key == '-f':
         # TODO(joi@chromium.org): Remove this override once change
         # lands in WebKit.grd to specify the first_ids_file in the
         # .grd itself.
         first_ids_file = val
       elif key == '-w':
         whitelist_filenames.append(val)
 
     if len(args):
-      print "This tool takes no tool-specific arguments."
+      print 'This tool takes no tool-specific arguments.'
       return 2
     self.SetOptions(opts)
     if self.scons_targets:
       self.VerboseOut('Using SCons targets to identify files to output.\n')
     else:
       self.VerboseOut('Output directory: %s (absolute path: %s)\n' %
                       (self.output_directory,
                        os.path.abspath(self.output_directory)))
 
     if whitelist_filenames:
       self.whitelist_names = set()
       for whitelist_filename in whitelist_filenames:
         self.VerboseOut('Using whitelist: %s\n' % whitelist_filename);
         whitelist_file = open(whitelist_filename)
         self.whitelist_names |= set(whitelist_file.read().strip().split('\n'))
         whitelist_file.close()
 
     self.res = grd_reader.Parse(opts.input,
                                 debug=opts.extra_verbose,
                                 first_ids_file=first_ids_file,
                                 defines=self.defines)
     # Set an output context so that conditionals can use defines during the
     # gathering stage; we use a dummy language here since we are not outputting
     # a specific language.
-    self.res.SetOutputContext('no-specific-language', self.defines)
+    self.res.SetOutputContext('en', self.defines)
     self.res.RunGatherers(recursive = True)
     self.Process()
     return 0
 
   def __init__(self, defines=None):
     # Default file-creation function is built-in file().  Only done to allow
     # overriding by unit test.
     self.fo_create = file
 
     # key/value pairs of C-preprocessor like defines that are used for
     # conditional output of resources
-    if defines:
-      self.defines = defines
-    else:
-      self.defines = {}
+    self.defines = defines or {}
 
     # self.res is a fully-populated resource tree if Run()
     # has been called, otherwise None.
     self.res = None
 
     # Set to a list of filenames for the output nodes that are relative
     # to the current working directory.  They are in the same order as the
     # output nodes in the file.
     self.scons_targets = None
 
@@ skipping 33 matching lines @@
     # Note: Some Format calls have side effects, so Format is always called
     # and the whitelist is used to only avoid the output.
     should_write = not node.WhitelistMarkedAsSkip()
 
     base_dir = util.dirname(output_node.GetOutputFilename())
 
     try:
       formatter = node.ItemFormatter(output_node.GetType())
       if formatter:
         formatted = formatter.Format(node, output_node.GetLanguage(),
-                                     begin_item=True, output_dir=base_dir)
+                                     output_dir=base_dir)
         if should_write:
           outfile.write(formatted)
     except:
-      print u"Error processing node %s" % unicode(node)
+      print u'Error processing node %s' % unicode(node)
       raise
 
     for child in node.children:
       RcBuilder.ProcessNode(child, output_node, outfile)
 
     try:
       if formatter:
-        formatted = formatter.Format(node, output_node.GetLanguage(),
-                                     begin_item=False, output_dir=base_dir)
+        formatted = formatter.FormatEnd(node, output_node.GetLanguage(),
+                                        output_dir=base_dir)
         if should_write:
           outfile.write(formatted)
     except:
-      print u"Error processing node %s" % unicode(node)
+      print u'Error processing node %s' % unicode(node)
       raise
   ProcessNode = staticmethod(ProcessNode)
 
 
   def Process(self):
     # Update filenames with those provided by SCons if we're being invoked
     # from SCons.  The list of SCons targets also includes all <structure>
     # node outputs, but it starts with our output files, in the order they
     # occur in the .grd
     if self.scons_targets:
@@ skipping 80 matching lines @@
 
     # Print out any fallback warnings, and missing translation errors, and
     # exit with an error code if there are missing translations in a non-pseudo
     # and non-official build.
     warnings = (self.res.UberClique().MissingTranslationsReport().
         encode('ascii', 'replace'))
     if warnings and self.defines.get('_google_chrome', False):
       print warnings
     if self.res.UberClique().HasMissingTranslations():
       sys.exit(-1)